home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / terminal / term / extras / source / term-source.lha / PhonePanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-26  |  75.6 KB  |  3,041 lines
  1. /*
  2. **    PhonePanel.c
  3. **
  4. **    The phonebook and support routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #include "termGlobal.h"
  13.  
  14.     // The gadget IDs are in there
  15.  
  16. #include "PhonePanel.h"
  17.  
  18.     /* What action is to follow clicking into the listview. */
  19.  
  20. enum    {    CLICK_NONE,CLICK_SELECT,CLICK_TOGGLE,CLICK_DIAL };
  21.  
  22. STATIC VOID __regargs
  23. HighlightEntry(LayoutHandle *Manager,LayoutHandle *Editor,struct List *PhoneList,struct PhoneNode *Node,ULONG Count,ULONG Grouper,BOOL Activate,BOOL Hide,BOOL NewList)
  24. {
  25.     BOOL IsFirst,IsLast,Disabled;
  26.  
  27.     if(Node && PhoneList)
  28.     {
  29.         IsFirst        = (Node == (struct PhoneNode *)PhoneList -> lh_Head);
  30.         IsLast        = (Node == (struct PhoneNode *)PhoneList -> lh_TailPred);
  31.         Disabled    = FALSE;
  32.     }
  33.     else
  34.     {
  35.         IsFirst        = TRUE;
  36.         IsLast        = TRUE;
  37.         Disabled    = TRUE;
  38.     }
  39.  
  40.     if(PhoneList)
  41.     {
  42.         LT_SetAttributes(Manager,GAD_NAMELIST,
  43.             NewList ? GTLV_Labels : TAG_IGNORE,    PhoneList,
  44.             Node ? TAG_IGNORE : GTLV_Selected,    ~0,
  45.         TAG_DONE);
  46.     }
  47.     else
  48.     {
  49.         LT_SetAttributes(Manager,GAD_NAMELIST,
  50.             GTLV_Labels,                        NULL,
  51.             Node ? TAG_IGNORE : GTLV_Selected, ~0,
  52.             Kick30 ? GA_Disabled : TAG_IGNORE,    TRUE,
  53.         TAG_DONE);
  54.     }
  55.  
  56.     LT_SetAttributes(Manager,GAD_COMMENTLINE,
  57.         GTTX_Text,    Node ? Node -> Entry -> Header -> Comment : (STRPTR)"",
  58.     TAG_DONE);
  59.  
  60.     LT_SetAttributes(Manager,GAD_MOVE_FIRST,
  61.         GA_Disabled,    IsFirst || Disabled,
  62.     TAG_DONE);
  63.  
  64.     LT_SetAttributes(Manager,GAD_MOVE_UP,
  65.         GA_Disabled,    IsFirst || Disabled,
  66.     TAG_DONE);
  67.  
  68.     LT_SetAttributes(Manager,GAD_MOVE_DOWN,
  69.         GA_Disabled,    IsLast || Disabled,
  70.     TAG_DONE);
  71.  
  72.     LT_SetAttributes(Manager,GAD_MOVE_LAST,
  73.         GA_Disabled,    IsLast || Disabled,
  74.     TAG_DONE);
  75.  
  76.     LT_SetAttributes(Manager,GAD_EDIT,
  77.         GA_Disabled,    !Node || Disabled,
  78.     TAG_DONE);
  79.  
  80.     LT_SetAttributes(Manager,GAD_COPY,
  81.         GA_Disabled,    !Node || Disabled,
  82.     TAG_DONE);
  83.  
  84.     LT_SetAttributes(Manager,GAD_DELETE,
  85.         GA_Disabled,    !Node || Disabled || Node -> Entry == ChosenEntry,
  86.     TAG_DONE);
  87.  
  88.     LT_SetAttributes(Manager,GAD_USE,
  89.         GA_Disabled,    !Node || Disabled,
  90.     TAG_DONE);
  91.  
  92.     LT_SetAttributes(Manager,GAD_MAKE_GROUP,
  93.         GA_Disabled,    !Node && !Count,
  94.     TAG_DONE);
  95.  
  96.     LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  97.         GA_Disabled,    Grouper == 0,
  98.     TAG_DONE);
  99.  
  100.     LT_SetAttributes(Manager,GAD_SELECT,
  101.         GA_Disabled,    Disabled || (Node && Node -> Entry -> Count != -1),
  102.     TAG_DONE);
  103.  
  104.     LT_SetAttributes(Manager,GAD_CLEAR,
  105.         GA_Disabled,    Disabled || (Node && Node -> Entry -> Count == -1),
  106.     TAG_DONE);
  107.  
  108.     LT_SetAttributes(Manager,GAD_TOGGLE_ALL,
  109.         GA_Disabled,    Disabled,
  110.     TAG_DONE);
  111.  
  112.     LT_SetAttributes(Manager,GAD_SELECT_ALL,
  113.         GA_Disabled,    !NumPhoneEntries || Count == NumPhoneEntries || !PhoneList,
  114.     TAG_DONE);
  115.  
  116.     LT_SetAttributes(Manager,GAD_CLEAR_ALL,
  117.         GA_Disabled,    !Count,
  118.     TAG_DONE);
  119.  
  120.     LT_SetAttributes(Manager,GAD_PATTERN,
  121.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  122.     TAG_DONE);
  123.  
  124.     LT_SetAttributes(Manager,GAD_DIAL,
  125.         GA_Disabled,    !Node || (Online && !Config -> MiscConfig -> ProtectiveMode),
  126.     TAG_DONE);
  127.  
  128.     LT_SetAttributes(Manager,GAD_LOAD,
  129.         GA_Disabled,    ChosenEntry != NULL,
  130.     TAG_DONE);
  131.  
  132.     LT_SetAttributes(Manager,GAD_MERGE,
  133.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  134.     TAG_DONE);
  135.  
  136.     LT_SetAttributes(Manager,GAD_SAVE,
  137.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  138.     TAG_DONE);
  139.  
  140.     LT_SetAttributes(Manager,GAD_PRINT,
  141.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  142.     TAG_DONE);
  143.  
  144.     LT_SetAttributes(Manager,GAD_SORT,
  145.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  146.     TAG_DONE);
  147.  
  148.     LT_SetAttributes(Manager,GAD_COPY_CONFIG,
  149.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  150.     TAG_DONE);
  151.  
  152.     LT_SetAttributes(Manager,GAD_SORT_ORDER,
  153.         GA_Disabled,    !NumPhoneEntries || !PhoneList,
  154.     TAG_DONE);
  155.  
  156.     LT_SetAttributes(Manager,GAD_GROUPID,
  157.         GTCY_Active,    Grouper,
  158.     TAG_DONE);
  159.  
  160.     if(Editor)
  161.     {
  162.         BOOL                     IsFirst,IsLast,Disabled,RatesValid;
  163.         struct Configuration    *LocalConfig;
  164.  
  165.         if(Node)
  166.         {
  167.             IsFirst            = (Node -> Entry -> Count == -1) || (Node -> Entry -> Count == 0);
  168.             IsLast            = (Node -> Entry -> Count == -1) || (Node -> Entry -> Count == Count - 1);
  169.             Disabled        = FALSE;
  170.             LocalConfig        = Node -> Entry -> Config;
  171.             RatesValid        = (Node -> Entry -> TimeDateList . mlh_Head -> mln_Succ != NULL && !Node -> Entry -> Header -> NoRates);
  172.         }
  173.         else
  174.         {
  175.             IsFirst            = TRUE;
  176.             IsLast            = TRUE;
  177.             Disabled        = TRUE;
  178.             LocalConfig        = NULL;
  179.             RatesValid        = FALSE;
  180.         }
  181.  
  182.         LT_SetAttributes(Editor,GAD_SYSTEM_NAME,
  183.             GTST_String,    Node ? Node -> Entry -> Header -> Name : (STRPTR)"",
  184.             GA_Disabled,    Disabled,
  185.         TAG_DONE);
  186.  
  187.         LT_SetAttributes(Editor,GAD_COMMENT,
  188.             GTST_String,    Node ? Node -> Entry -> Header -> Comment : (STRPTR)"",
  189.             GA_Disabled,    Disabled,
  190.         TAG_DONE);
  191.  
  192.         LT_SetAttributes(Editor,GAD_NUMBERS,
  193.             GTST_String,    Node ? Node -> Entry -> Header -> Number : (STRPTR)"",
  194.             GA_Disabled,    Disabled,
  195.         TAG_DONE);
  196.  
  197.         LT_SetAttributes(Editor,GAD_QUICK_MENU,
  198.             GTCB_Checked,    Node ? Node -> Entry -> Header -> QuickMenu : FALSE,
  199.             GA_Disabled,    Disabled,
  200.         TAG_DONE);
  201.  
  202.         LT_SetAttributes(Editor,GAD_AUTODIAL,
  203.             GTCB_Checked,    Node ? Node -> Entry -> Header -> AutoDial : FALSE,
  204.             GA_Disabled,    Disabled,
  205.         TAG_DONE);
  206.  
  207.         LT_SetAttributes(Editor,GAD_USER_NAME,
  208.             GTST_String,    (Node && !Hide) ? Node -> Entry -> Header -> UserName : (STRPTR)"",
  209.             GA_Disabled,    Hide || Disabled,
  210.         TAG_DONE);
  211.  
  212.         LT_SetAttributes(Editor,GAD_USER_PASSWORD,
  213.             GTST_String,    (Node && !Hide) ? Node -> Entry -> Header -> Password : (STRPTR)"",
  214.             GA_Disabled,    Hide || Disabled,
  215.         TAG_DONE);
  216.  
  217.  
  218.         LT_SetAttributes(Editor,GAD_SERIAL_STATE,
  219.             GTCB_Checked,    LocalConfig ? (LocalConfig -> SerialConfig != NULL) : FALSE,
  220.             GA_Disabled,    Disabled,
  221.         TAG_DONE);
  222.  
  223.         LT_SetAttributes(Editor,GAD_SERIAL_EDIT,
  224.                 GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> SerialConfig),
  225.         TAG_DONE);
  226.  
  227.         LT_SetAttributes(Editor,GAD_MODEM_STATE,
  228.             GTCB_Checked,    LocalConfig ? (LocalConfig -> ModemConfig != NULL) : FALSE,
  229.             GA_Disabled,    Disabled,
  230.         TAG_DONE);
  231.  
  232.         LT_SetAttributes(Editor,GAD_MODEM_EDIT,
  233.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> ModemConfig),
  234.         TAG_DONE);
  235.  
  236.         LT_SetAttributes(Editor,GAD_SCREEN_STATE,
  237.             GTCB_Checked,    LocalConfig ? (LocalConfig -> ScreenConfig != NULL) : FALSE,
  238.             GA_Disabled,    Disabled,
  239.         TAG_DONE);
  240.  
  241.         LT_SetAttributes(Editor,GAD_SCREEN_EDIT,
  242.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> ScreenConfig),
  243.         TAG_DONE);
  244.  
  245.         LT_SetAttributes(Editor,GAD_TERMINAL_STATE,
  246.             GTCB_Checked,    LocalConfig ? (LocalConfig -> TerminalConfig != NULL) : FALSE,
  247.             GA_Disabled,    Disabled,
  248.         TAG_DONE);
  249.  
  250.         LT_SetAttributes(Editor,GAD_TERMINAL_EDIT,
  251.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> TerminalConfig),
  252.         TAG_DONE);
  253.  
  254.         LT_SetAttributes(Editor,GAD_EMULATION_STATE,
  255.             GTCB_Checked,    LocalConfig ? (LocalConfig -> EmulationConfig != NULL) : FALSE,
  256.             GA_Disabled,    Disabled,
  257.         TAG_DONE);
  258.  
  259.         LT_SetAttributes(Editor,GAD_EMULATION_EDIT,
  260.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> EmulationConfig),
  261.         TAG_DONE);
  262.  
  263.         LT_SetAttributes(Editor,GAD_CLIPBOARD_STATE,
  264.             GTCB_Checked,    LocalConfig ? (LocalConfig -> ClipConfig != NULL) : FALSE,
  265.             GA_Disabled,    Disabled,
  266.         TAG_DONE);
  267.  
  268.         LT_SetAttributes(Editor,GAD_CLIPBOARD_EDIT,
  269.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> ClipConfig),
  270.         TAG_DONE);
  271.  
  272.         LT_SetAttributes(Editor,GAD_CAPTURE_STATE,
  273.             GTCB_Checked,    LocalConfig ? (LocalConfig -> CaptureConfig != NULL) : FALSE,
  274.             GA_Disabled,    Disabled,
  275.         TAG_DONE);
  276.  
  277.         LT_SetAttributes(Editor,GAD_CAPTURE_EDIT,
  278.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> CaptureConfig),
  279.         TAG_DONE);
  280.  
  281.         LT_SetAttributes(Editor,GAD_COMMAND_STATE,
  282.             GTCB_Checked,    LocalConfig ? (LocalConfig -> CommandConfig != NULL) : FALSE,
  283.             GA_Disabled,    Disabled,
  284.         TAG_DONE);
  285.  
  286.         LT_SetAttributes(Editor,GAD_COMMAND_EDIT,
  287.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> CommandConfig),
  288.         TAG_DONE);
  289.  
  290.         LT_SetAttributes(Editor,GAD_MISC_STATE,
  291.             GTCB_Checked,    LocalConfig ? (LocalConfig -> MiscConfig != NULL) : FALSE,
  292.             GA_Disabled,    Disabled,
  293.         TAG_DONE);
  294.  
  295.         LT_SetAttributes(Editor,GAD_MISC_EDIT,
  296.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> MiscConfig),
  297.         TAG_DONE);
  298.  
  299.         LT_SetAttributes(Editor,GAD_PATH_STATE,
  300.             GTCB_Checked,    LocalConfig ? (LocalConfig -> PathConfig != NULL) : FALSE,
  301.             GA_Disabled,    Disabled,
  302.         TAG_DONE);
  303.  
  304.         LT_SetAttributes(Editor,GAD_PATH_EDIT,
  305.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> PathConfig),
  306.         TAG_DONE);
  307.  
  308.         LT_SetAttributes(Editor,GAD_TRANSFER_STATE,
  309.             GTCB_Checked,    LocalConfig ? (LocalConfig -> TransferConfig != NULL) : FALSE,
  310.             GA_Disabled,    Disabled,
  311.         TAG_DONE);
  312.  
  313.         LT_SetAttributes(Editor,GAD_TRANSFER_EDIT,
  314.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> TransferConfig),
  315.         TAG_DONE);
  316.  
  317.         LT_SetAttributes(Editor,GAD_TRANSLATION_STATE,
  318.             GTCB_Checked,    LocalConfig ? (LocalConfig -> TranslationFileName != NULL) : FALSE,
  319.             GA_Disabled,    Disabled,
  320.         TAG_DONE);
  321.  
  322.         LT_SetAttributes(Editor,GAD_TRANSLATION_EDIT,
  323.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> TranslationFileName),
  324.         TAG_DONE);
  325.  
  326.         LT_SetAttributes(Editor,GAD_MACRO_STATE,
  327.             GTCB_Checked,    LocalConfig ? (LocalConfig -> MacroFileName != NULL) : FALSE,
  328.             GA_Disabled,    Disabled,
  329.         TAG_DONE);
  330.  
  331.         LT_SetAttributes(Editor,GAD_MACRO_EDIT,
  332.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> MacroFileName),
  333.         TAG_DONE);
  334.  
  335.         LT_SetAttributes(Editor,GAD_CURSOR_STATE,
  336.             GTCB_Checked,    LocalConfig ? (LocalConfig -> CursorFileName != NULL) : FALSE,
  337.             GA_Disabled,    Disabled,
  338.         TAG_DONE);
  339.  
  340.         LT_SetAttributes(Editor,GAD_CURSOR_EDIT,
  341.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> CursorFileName),
  342.         TAG_DONE);
  343.  
  344.         LT_SetAttributes(Editor,GAD_FASTMACRO_STATE,
  345.             GTCB_Checked,    LocalConfig ? (LocalConfig -> FastMacroFileName != NULL) : FALSE,
  346.             GA_Disabled,    Disabled,
  347.         TAG_DONE);
  348.  
  349.         LT_SetAttributes(Editor,GAD_FASTMACRO_EDIT,
  350.             GA_Disabled,    Disabled || (LocalConfig && !LocalConfig -> FastMacroFileName),
  351.         TAG_DONE);
  352.  
  353.         LT_SetAttributes(Editor,GAD_RATE_STATE,
  354.             GTCB_Checked,    RatesValid,
  355.             GA_Disabled,    Disabled,
  356.         TAG_DONE);
  357.  
  358.         LT_SetAttributes(Editor,GAD_RATE_EDIT,
  359.             GA_Disabled,    Disabled || !RatesValid,
  360.         TAG_DONE);
  361.  
  362.         LT_SetAttributes(Editor,GAD_FIRST_ENTRY,
  363.             GA_Disabled,    Disabled || IsFirst,
  364.         TAG_DONE);
  365.  
  366.         LT_SetAttributes(Editor,GAD_PREVIOUS_ENTRY,
  367.             GA_Disabled,    Disabled || IsFirst,
  368.         TAG_DONE);
  369.  
  370.         LT_SetAttributes(Editor,GAD_NEXT_ENTRY,
  371.             GA_Disabled,    Disabled || IsLast,
  372.         TAG_DONE);
  373.  
  374.         LT_SetAttributes(Editor,GAD_LAST_ENTRY,
  375.             GA_Disabled,    Disabled || IsLast,
  376.         TAG_DONE);
  377.  
  378.         if(Activate)
  379.         {
  380.             LT_ShowWindow(Editor,TRUE);
  381.  
  382.             LT_Activate(Editor,GAD_SYSTEM_NAME);
  383.         }
  384.     }
  385. }
  386.  
  387. STATIC VOID __regargs
  388. UpdateWindowTitle(struct Window *Window,STRPTR Title,LONG Count)
  389. {
  390.     if(Count)
  391.         SPrintf(Title,LocaleString(MSG_PHONEPANEL_SELECTED_OUT_OF_TXT),LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT),Count,NumPhoneEntries);
  392.     else
  393.         Title = LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT);
  394.  
  395.     SetWindowTitles(Window,Title,(STRPTR)~0);
  396. }
  397.  
  398. BOOL __regargs
  399. PhonePanel(ULONG MsgQualifier)
  400. {
  401.     STATIC UBYTE    NamePattern[64]        = "#?",
  402.                     NumberPattern[64]    = "#?",
  403.                     CommentPattern[64]    = "#?";
  404.     STATIC BYTE        Mode = 1;
  405.  
  406.     STATIC WORD        Sorter;
  407.     STATIC BOOL        ReverseOrder;
  408.  
  409.     UBYTE                 ParsedNamePattern[130],
  410.                          ParsedNumberPattern[130],
  411.                          ParsedCommentPattern[130];
  412.  
  413.     UBYTE                 WindowTitle[80];
  414.  
  415.     struct MsgPort        *UserPort;
  416.     LayoutHandle        *Manager,
  417.                         *Editor,
  418.                         *Selector,
  419.                         *Grouping,
  420.                         *Sorting;
  421.     struct PhoneNode    *TempNode;
  422.     struct List            *PhoneList;
  423.     struct List            *CurrentList;
  424.     LONG                 Count;
  425.     BOOL                 DialTheList = FALSE;
  426.     STRPTR                *Labels,
  427.                         *OtherLabels;
  428.     STRPTR                 Name;
  429.     LONG                 i,ListMax;
  430.     BOOL                 Hide = TRUE;
  431.  
  432.         // Create the group labels
  433.  
  434.     if(!(Labels = BuildLabels()))
  435.     {
  436.         DisplayBeep(Window -> WScreen);
  437.         return(FALSE);
  438.     }
  439.  
  440.         // Count the number of labels
  441.  
  442.     for(i = 0 ; Labels[i] ; i++);
  443.  
  444.         // If the group index is larger than the group label table
  445.         // permits, truncate it.
  446.  
  447.     if(PhonebookDefaultGroup >= i)
  448.         PhonebookDefaultGroup = i - 1;
  449.  
  450.         // All the control panels we will open will live on this msgport
  451.  
  452.     if(!(UserPort = CreateMsgPort()))
  453.     {
  454.         FreeVecPooled(Labels);
  455.         DisplayBeep(Window -> WScreen);
  456.         return(FALSE);
  457.     }
  458.  
  459.         // Start with a clean slate
  460.  
  461.     Manager        = NULL;
  462.     Editor        = NULL;
  463.     Selector    = NULL;
  464.     Grouping    = NULL;
  465.     Sorting        = NULL;
  466.  
  467.         // Does the phonebook hold any entries?
  468.  
  469.     if(Phonebook && NumPhoneEntries)
  470.     {
  471.         LONG i;
  472.  
  473.             // Create the phonebook labels
  474.  
  475.         if(!(PhoneList = CreatePhoneList()))
  476.         {
  477.             DisplayBeep(Window -> WScreen);
  478.  
  479.             FreeVecPooled(Labels);
  480.             DeleteMsgPort(UserPort);
  481.  
  482.             return(FALSE);
  483.         }
  484.  
  485.             // Get rid of the old dialing list
  486.  
  487.         FreeDialList(TRUE);
  488.  
  489.             // Now walk through the phonebook, counting the tagged entries
  490.  
  491.         for(i = 0, Count = -1 ; i < NumPhoneEntries ; i++)
  492.         {
  493.             if(Phonebook[i] -> Count > Count)
  494.                 Count = Phonebook[i] -> Count;
  495.         }
  496.  
  497.         Count++;
  498.     }
  499.     else
  500.     {
  501.         PhoneList    = NULL;
  502.         Count        = 0;
  503.     }
  504.  
  505.         // Are we to display a group?
  506.  
  507.     if(PhonebookDefaultGroup)
  508.     {
  509.         PhoneGroupNode    *Group;
  510.         struct Node        *Node;
  511.  
  512.             // Get the group list header
  513.  
  514.         Group = (PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName));
  515.  
  516.         CurrentList = (struct List *)&Group -> GroupList;
  517.  
  518.             // Count the number of entries in the list
  519.  
  520.         for(ListMax = 0, Node = CurrentList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  521.             ListMax++;
  522.     }
  523.     else
  524.     {
  525.             // We'll use the main list
  526.  
  527.         CurrentList    = PhoneList;
  528.         ListMax        = NumPhoneEntries;
  529.     }
  530.  
  531.         // Update the window title
  532.  
  533.     if(Count)
  534.         SPrintf(WindowTitle,LocaleString(MSG_PHONEPANEL_SELECTED_OUT_OF_TXT),LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT),Count,NumPhoneEntries);
  535.     else
  536.         strcpy(WindowTitle,LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT));
  537.  
  538.         // If the user holds down any shift key, the editor window will open in
  539.         // addition to the manager window
  540.  
  541.     if(MsgQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
  542.     {
  543.         if(Editor = CreateEditorHandle(Window,CurrentList,Count,NULL,FALSE,UserPort))
  544.             Manager = CreateManagerHandle(Editor -> Window,CurrentList,Count,&PhonebookDefaultGroup,Labels,UserPort,WindowTitle);
  545.     }
  546.     else
  547.         Manager = CreateManagerHandle(Window,CurrentList,Count,&PhonebookDefaultGroup,Labels,UserPort,WindowTitle);
  548.  
  549.         // Don't go any further if the manager window is not open
  550.  
  551.     if(Manager)
  552.     {
  553.         struct IntuiMessage        *Message;
  554.         BOOLEAN                     Done = FALSE;
  555.         ULONG                     MsgClass,
  556.                                  MsgQualifier,
  557.                                  CompleteQualifier;
  558.         UWORD                     MsgCode;
  559.         UWORD                     KeyCode;
  560.         struct Gadget            *MsgGadget;
  561.         struct Window            *MsgWindow;
  562.  
  563.         BYTE                     ClickAction;
  564.  
  565.         UBYTE                     DummyBuffer[MAX_FILENAME_LENGTH],
  566.                                 *DummyChar;
  567.  
  568.         LONG                     Selected = ~0,
  569.                                  MsgGadgetID;
  570.  
  571.         struct PhoneNode        *SelectedNode = NULL;
  572.  
  573.         struct FileRequester    *FileRequest;
  574.         WORD                     Vanilla;
  575.  
  576.         struct Window            *PhoneWindow    = Manager -> Window;
  577.         struct Window            *EditWindow        = NULL;
  578.         struct Window            *PatternWindow    = NULL;
  579.         struct Window            *GroupWindow    = NULL;
  580.         struct Window            *SortWindow        = NULL;
  581.         LayoutHandle            *Handle;
  582.  
  583.             // Save this one for later
  584.  
  585.         if(Editor)
  586.             EditWindow = Editor -> Window;
  587.  
  588.         GuideContext(CONTEXT_PHONEBOOK);
  589.  
  590.         PushWindow(PhoneWindow);
  591.  
  592.         do
  593.         {
  594.             if(Wait(PORTMASK(PhoneWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  595.             {
  596.                 FreeDialList(TRUE);
  597.  
  598.                 break;
  599.             }
  600.  
  601.             while(Message = (struct IntuiMessage *)GT_GetIMsg(PhoneWindow -> UserPort))
  602.             {
  603.                 MsgClass        = Message -> Class;
  604.                 MsgQualifier    = Message -> Qualifier;
  605.                 MsgCode            = Message -> Code;
  606.                 MsgGadget        = (struct Gadget *)Message -> IAddress;
  607.                 MsgWindow        = Message -> IDCMPWindow;
  608.  
  609.                 GT_ReplyIMsg(Message);
  610.  
  611.                     // Jump to the handle the message originated from
  612.  
  613.                 if(MsgWindow == PhoneWindow)
  614.                     Handle = Manager;
  615.  
  616.                 if(MsgWindow == EditWindow)
  617.                     Handle = Editor;
  618.  
  619.                 if(MsgWindow == PatternWindow)
  620.                     Handle = Selector;
  621.  
  622.                 if(MsgWindow == GroupWindow)
  623.                     Handle = Grouping;
  624.  
  625.                 if(MsgWindow == SortWindow)
  626.                     Handle = Sorting;
  627.  
  628.                     // Save the original event qualifier
  629.  
  630.                 CompleteQualifier = MsgQualifier;
  631.  
  632.                     // Now, this is not nice, but needs to be done in order
  633.                     // to avoid having keyboard movements mess up the list of
  634.                     // tagged entries.
  635.  
  636.                 if(MsgClass == IDCMP_RAWKEY && (MsgCode >= CURSORUP && MsgCode <= CURSORDOWN))
  637.                     MsgQualifier &= ~(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT);
  638.  
  639.                     // We'll save the key code for the editing window
  640.  
  641.                 if(MsgClass == IDCMP_RAWKEY)
  642.                     KeyCode = MsgCode;
  643.                 else
  644.                     KeyCode = 0;
  645.  
  646.                     // Let gtlayout take its share
  647.  
  648.                 LT_HandleInput(Handle,CompleteQualifier,&MsgClass,&MsgCode,&MsgGadget);
  649.  
  650.                     // Extract the gadget ID
  651.  
  652.                 if(MsgClass == IDCMP_GADGETUP || MsgClass == IDCMP_IDCMPUPDATE)
  653.                     MsgGadgetID = MsgGadget -> GadgetID;
  654.                 else
  655.                     MsgGadgetID = -1;
  656.  
  657.                     // Now convert the raw key code for special commands
  658.  
  659.                 Vanilla = LT_GetCode(CompleteQualifier,MsgClass,MsgCode,MsgGadget);
  660.  
  661.                 switch(Vanilla)
  662.                 {
  663.                         // Toggle the current entry
  664.  
  665.                     case ' ':
  666.  
  667.                         if(SelectedNode)
  668.                         {
  669.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  670.                                 GTLV_Labels,    ~0,
  671.                             TAG_DONE);
  672.  
  673.                             if(SelectedNode -> Entry -> Count == -1)
  674.                             {
  675.                                 SelectedNode -> Entry -> Count = Count++;
  676.  
  677.                                 SPrintf(SelectedNode -> LocalName,"%3ld - %s",Count,SelectedNode -> Entry -> Header -> Name);
  678.  
  679.                                 if(SelectedNode -> Entry -> NodeGroup)
  680.                                     strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> LocalName);
  681.  
  682.                                 UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  683.                             }
  684.                             else
  685.                             {
  686.                                 RemoveDialEntry(SelectedNode);
  687.  
  688.                                 Count--;
  689.  
  690.                                 UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  691.                             }
  692.  
  693.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  694.                                 GTLV_Labels,        CurrentList,
  695.                                 GTLV_Selected,        Selected,
  696.                             TAG_DONE);
  697.  
  698.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  699.                         }
  700.  
  701.                         break;
  702.  
  703.                         // Untag this or all entries
  704.  
  705.                     case 127:
  706.  
  707.                         if(CompleteQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
  708.                         {
  709.                             if(Count > 0)
  710.                             {
  711.                                 MsgClass    = IDCMP_GADGETUP;
  712.                                 MsgGadgetID    = GAD_CLEAR_ALL;
  713.  
  714.                                 LT_PressButton(Handle,MsgGadgetID);
  715.                             }
  716.                         }
  717.                         else
  718.                         {
  719.                             if(Selected != -1 && SelectedNode -> Entry -> Count != -1)
  720.                             {
  721.                                 MsgClass    = IDCMP_GADGETUP;
  722.                                 MsgGadgetID    = GAD_CLEAR;
  723.  
  724.                                 LT_PressButton(Handle,MsgGadgetID);
  725.                             }
  726.                         }
  727.  
  728.                         break;
  729.                 }
  730.  
  731.                     // Moving around through the editing window
  732.  
  733.                 if(MsgWindow == EditWindow && KeyCode)
  734.                 {
  735.                     switch(KeyCode)
  736.                     {
  737.                         case CURSORLEFT:
  738.  
  739.                             MsgGadgetID = -1;
  740.  
  741.                             if(SelectedNode && SelectedNode -> Entry -> Count > 0)
  742.                             {
  743.                                 MsgClass = IDCMP_GADGETUP;
  744.  
  745.                                 if(CompleteQualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
  746.                                     MsgGadgetID    = GAD_FIRST_ENTRY;
  747.                                 else
  748.                                     MsgGadgetID    = GAD_PREVIOUS_ENTRY;
  749.  
  750.                                 LT_PressButton(Handle,MsgGadgetID);
  751.                             }
  752.  
  753.                             break;
  754.  
  755.                         case CURSORRIGHT:
  756.  
  757.                             MsgGadgetID = -1;
  758.  
  759.                             if(SelectedNode && SelectedNode -> Entry -> Count < Count - 1)
  760.                             {
  761.                                 MsgClass = IDCMP_GADGETUP;
  762.  
  763.                                 if(CompleteQualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
  764.                                     MsgGadgetID    = GAD_LAST_ENTRY;
  765.                                 else
  766.                                     MsgGadgetID    = GAD_NEXT_ENTRY;
  767.  
  768.                                 LT_PressButton(Handle,MsgGadgetID);
  769.                             }
  770.  
  771.                             break;
  772.                     }
  773.                 }
  774.  
  775.                     // Close a window
  776.  
  777.                 if(MsgClass == IDCMP_CLOSEWINDOW)
  778.                 {
  779.                     if(MsgWindow == PhoneWindow)
  780.                     {
  781.                         FreeDialList(TRUE);
  782.  
  783.                         Done = TRUE;
  784.                     }
  785.  
  786.                     if(MsgWindow == EditWindow)
  787.                     {
  788.                         LT_DeleteHandle(Editor);
  789.  
  790.                         Editor = NULL;
  791.                         EditWindow = NULL;
  792.  
  793.                         LT_ShowWindow(Manager,TRUE);
  794.                     }
  795.  
  796.                     if(MsgWindow == PatternWindow)
  797.                     {
  798.                         LT_DeleteHandle(Selector);
  799.                         Selector = NULL;
  800.                         PatternWindow = NULL;
  801.  
  802.                         LT_ShowWindow(Manager,TRUE);
  803.                     }
  804.  
  805.                     if(MsgWindow == GroupWindow)
  806.                     {
  807.                         LT_DeleteHandle(Grouping);
  808.                         Grouping = NULL;
  809.                         GroupWindow = NULL;
  810.  
  811.                         LT_ShowWindow(Manager,TRUE);
  812.                     }
  813.  
  814.                     if(MsgWindow == SortWindow)
  815.                     {
  816.                         LT_DeleteHandle(Sorting);
  817.                         Sorting = NULL;
  818.                         SortWindow = NULL;
  819.  
  820.                         LT_ShowWindow(Manager,TRUE);
  821.                     }
  822.                 }
  823.  
  824.                     // Hit a gadget
  825.  
  826.                 if(MsgClass == IDCMP_GADGETUP)
  827.                 {
  828.                     switch(MsgGadgetID)
  829.                     {
  830.                             // Toggle all entries
  831.  
  832.                         case GAD_TOGGLE_ALL:
  833.                         {
  834.                             LONG LocalCount = 0;
  835.  
  836.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  837.                                 GTLV_Labels,    ~0,
  838.                             TAG_DONE);
  839.  
  840.                             for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  841.                             {
  842.                                 if(TempNode -> Entry -> Count == -1)
  843.                                 {
  844.                                     TempNode -> Entry -> Count = LocalCount++;
  845.  
  846.                                     SPrintf(TempNode -> LocalName,"%3ld - %s",LocalCount,TempNode -> Entry -> Header -> Name);
  847.  
  848.                                     if(TempNode -> Entry -> NodeGroup)
  849.                                         strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  850.                                 }
  851.                                 else
  852.                                     RemoveDialEntry(TempNode);
  853.                             }
  854.  
  855.                             Count = LocalCount;
  856.  
  857.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  858.  
  859.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  860.  
  861.                             break;
  862.                         }
  863.  
  864.                             // Select all entries
  865.  
  866.                         case GAD_SELECT_ALL:
  867.  
  868.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  869.                                 GTLV_Labels,    ~0,
  870.                             TAG_DONE);
  871.  
  872.                             for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  873.                             {
  874.                                 if(TempNode -> Entry -> Count == -1)
  875.                                 {
  876.                                     TempNode -> Entry -> Count = Count++;
  877.  
  878.                                     SPrintf(TempNode -> LocalName,"%3ld - %s",Count,TempNode -> Entry -> Header -> Name);
  879.  
  880.                                     if(TempNode -> Entry -> NodeGroup)
  881.                                         strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  882.                                 }
  883.                             }
  884.  
  885.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  886.  
  887.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  888.  
  889.                             break;
  890.  
  891.                             // Tag the current entry
  892.  
  893.                         case GAD_SELECT:
  894.  
  895.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  896.                                 GTLV_Labels,    ~0,
  897.                             TAG_DONE);
  898.  
  899.                             SelectedNode -> Entry -> Count = Count++;
  900.  
  901.                             SPrintf(SelectedNode -> LocalName,"%3ld - %s",Count,SelectedNode -> Entry -> Header -> Name);
  902.  
  903.                             if(SelectedNode -> Entry -> NodeGroup)
  904.                                 strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> LocalName);
  905.  
  906.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  907.  
  908.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  909.  
  910.                             break;
  911.  
  912.                             // Untag the current entry
  913.  
  914.                         case GAD_CLEAR:
  915.  
  916.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  917.                                 GTLV_Labels,    ~0,
  918.                             TAG_DONE);
  919.  
  920.                             RemoveDialEntry(SelectedNode);
  921.  
  922.                             Count--;
  923.  
  924.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  925.  
  926.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  927.  
  928.                             break;
  929.  
  930.                             // Picked a list entry
  931.  
  932.                         case GAD_NAMELIST:
  933.  
  934.                             Selected = MsgCode;
  935.  
  936.                                 // Get the selected node entry from the right list
  937.  
  938.                             if(PhonebookDefaultGroup)
  939.                                 SelectedNode = (struct PhoneNode *)GetListNode(Selected,CurrentList);
  940.                             else
  941.                                 SelectedNode = Phonebook[Selected] -> Node;
  942.  
  943.                                 // Now check if the entry needs to be tagged or toggled
  944.  
  945.                             if(SelectedNode -> Entry -> Header -> Number[0] && SelectedNode -> Entry -> Header -> Name[0])
  946.                             {
  947.                                 if(MsgQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
  948.                                     ClickAction = CLICK_TOGGLE;
  949.                                 else
  950.                                     ClickAction = CLICK_SELECT;
  951.                             }
  952.                             else
  953.                                 ClickAction = CLICK_SELECT;
  954.  
  955.                                 // Toggle the tag
  956.  
  957.                             if(ClickAction == CLICK_TOGGLE)
  958.                             {
  959.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  960.                                     GTLV_Labels,    ~0,
  961.                                 TAG_DONE);
  962.  
  963.                                 if(SelectedNode -> Entry -> Count == -1)
  964.                                 {
  965.                                     SelectedNode -> Entry -> Count = Count++;
  966.  
  967.                                     SPrintf(SelectedNode -> LocalName,"%3ld - %s",Count,SelectedNode -> Entry -> Header -> Name);
  968.  
  969.                                     if(SelectedNode -> Entry -> NodeGroup)
  970.                                         strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> LocalName);
  971.                                 }
  972.                                 else
  973.                                 {
  974.                                     RemoveDialEntry(SelectedNode);
  975.  
  976.                                     Count--;
  977.                                 }
  978.  
  979.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  980.                                     GTLV_Labels,        CurrentList,
  981.                                     GTLV_Selected,        Selected,
  982.                                 TAG_DONE);
  983.                             }
  984.  
  985.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  986.  
  987.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  988.  
  989.                             break;
  990.  
  991.                             // Clear all selections in this group
  992.  
  993.                         case GAD_CLEAR_ALL:
  994.  
  995.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  996.                                 GTLV_Labels,    ~0,
  997.                             TAG_DONE);
  998.  
  999.                             for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  1000.                             {
  1001.                                 if(TempNode -> Entry -> Count != -1)
  1002.                                 {
  1003.                                     SPrintf(TempNode -> LocalName,"      %s",TempNode -> Entry -> Header -> Name);
  1004.  
  1005.                                     TempNode -> Entry -> Count = -1;
  1006.  
  1007.                                     Count--;
  1008.  
  1009.                                     if(TempNode -> Entry -> NodeGroup)
  1010.                                         strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  1011.                                 }
  1012.                             }
  1013.  
  1014.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1015.  
  1016.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1017.  
  1018.                             break;
  1019.  
  1020.                             // Print the current group
  1021.  
  1022.                         case GAD_PRINT:
  1023.  
  1024.                             LT_LockWindow(PhoneWindow);
  1025.                             LT_LockWindow(EditWindow);
  1026.                             LT_LockWindow(PatternWindow);
  1027.                             LT_LockWindow(GroupWindow);
  1028.                             LT_LockWindow(SortWindow);
  1029.  
  1030.                             PrintPanel(PhoneWindow,CurrentList,Count);
  1031.  
  1032.                             LT_UnlockWindow(PhoneWindow);
  1033.                             LT_UnlockWindow(EditWindow);
  1034.                             LT_UnlockWindow(PatternWindow);
  1035.                             LT_UnlockWindow(GroupWindow);
  1036.                             LT_UnlockWindow(SortWindow);
  1037.  
  1038.                             LT_ShowWindow(Handle,TRUE);
  1039.  
  1040.                             break;
  1041.  
  1042.                             // Copy the setting stored with the current entry
  1043.                             // into the global settings
  1044.  
  1045.                         case GAD_USE:
  1046.  
  1047.                             if(SelectedNode)
  1048.                             {
  1049.                                 SaveConfig(Config,PrivateConfig);
  1050.  
  1051.                                 SaveConfig(SelectedNode -> Entry -> Config,Config);
  1052.  
  1053.                                 strcpy(Password,SelectedNode -> Entry -> Header -> Password);
  1054.                                 strcpy(UserName,SelectedNode -> Entry -> Header -> UserName);
  1055.  
  1056.                                 ConfigSetup();
  1057.  
  1058.                                 Done = TRUE;
  1059.  
  1060.                                 ConfigChanged = FALSE;
  1061.                             }
  1062.  
  1063.                             break;
  1064.  
  1065.                             // Add a new phonebook entry to the group
  1066.  
  1067.                         case GAD_ADD:
  1068.  
  1069.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  1070.                                 GTLV_Labels,    ~0,
  1071.                             TAG_DONE);
  1072.  
  1073.                             if(PhoneList)
  1074.                             {
  1075.                                 DeletePhoneList(PhoneList);
  1076.  
  1077.                                 PhoneList = NULL;
  1078.                             }
  1079.  
  1080.                                 // Create the new entry
  1081.  
  1082.                             if(NewPhoneEntry())
  1083.                             {
  1084.                                     // Then fiddle with the list to display
  1085.  
  1086.                                 if(PhoneList = CreatePhoneList())
  1087.                                 {
  1088.                                         // New entries always end up at the end of the list
  1089.  
  1090.                                     SelectedNode = (struct PhoneNode *)PhoneList -> lh_TailPred;
  1091.  
  1092.                                         // Are we displaying a group?
  1093.  
  1094.                                     if(PhonebookDefaultGroup)
  1095.                                     {
  1096.                                         PhoneGroupNode *Group;
  1097.  
  1098.                                             // Link this entry into the group
  1099.  
  1100.                                         Group = (PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName));
  1101.  
  1102.                                         if(AddGroupEntry(Group,SelectedNode))
  1103.                                             ListMax++;
  1104.                                         else
  1105.                                         {
  1106.                                                 // If this went wrong, move up to the
  1107.                                                 // main list
  1108.  
  1109.                                             DisplayBeep(PhoneWindow -> WScreen);
  1110.  
  1111.                                             PhonebookDefaultGroup = 0;
  1112.  
  1113.                                             LT_SetAttributes(Manager,GAD_GROUPID,
  1114.                                                 GTCY_Active,0,
  1115.                                             TAG_DONE);
  1116.  
  1117.                                             CurrentList = PhoneList;
  1118.                                             ListMax = NumPhoneEntries;
  1119.                                         }
  1120.                                     }
  1121.                                     else
  1122.                                     {
  1123.                                             // This needs to be updated
  1124.  
  1125.                                         CurrentList = PhoneList;
  1126.                                         ListMax++;
  1127.                                     }
  1128.  
  1129.                                     Selected = ListMax - 1;
  1130.  
  1131.                                     LT_SetAttributes(Handle,GAD_NAMELIST,
  1132.                                         GTLV_Labels,        CurrentList,
  1133.                                         GTLV_Selected,        Selected,
  1134.                                     TAG_DONE);
  1135.  
  1136.                                         // Open the editor window so the user can edit the new entry
  1137.  
  1138.                                     if(!Editor)
  1139.                                     {
  1140.                                         if(Editor = CreateEditorHandle(Manager -> Window,CurrentList,Count,SelectedNode,TRUE,PhoneWindow -> UserPort))
  1141.                                             EditWindow = Editor -> Window;
  1142.                                     }
  1143.                                     else
  1144.                                         HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,TRUE,Hide,TRUE);
  1145.  
  1146.                                     RebuildMenu = PhonebookChanged = TRUE;
  1147.                                     UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1148.                                 }
  1149.                                 else
  1150.                                     goto ClearList;
  1151.                             }
  1152.                             else
  1153.                                 goto ClearList;
  1154.  
  1155.                             break;
  1156.  
  1157.                             // Edit the current entry
  1158.  
  1159.                         case GAD_EDIT:
  1160.  
  1161.                             if(SelectedNode)
  1162.                             {
  1163.                                 if(!Editor)
  1164.                                 {
  1165.                                     if(Editor = CreateEditorHandle(Manager -> Window,CurrentList,Count,SelectedNode,TRUE,PhoneWindow -> UserPort))
  1166.                                         EditWindow = Editor -> Window;
  1167.                                 }
  1168.                                 else
  1169.                                     HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,TRUE,Hide,FALSE);
  1170.                             }
  1171.  
  1172.                             break;
  1173.  
  1174.                             // Hide user name and password?
  1175.  
  1176.                         case GAD_HIDE_USERNAME_PASSWORD:
  1177.  
  1178.                             Hide = MsgCode;
  1179.  
  1180.                             if(SelectedNode)
  1181.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,TRUE,Hide,FALSE);
  1182.  
  1183.                             break;
  1184.  
  1185.                             // Make a copy of the current entry
  1186.  
  1187.                         case GAD_COPY:
  1188.  
  1189.                             if(SelectedNode)
  1190.                             {
  1191.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  1192.                                     GTLV_Labels,    ~0,
  1193.                                 TAG_DONE);
  1194.  
  1195.                                 if(PhoneList)
  1196.                                 {
  1197.                                     DeletePhoneList(PhoneList);
  1198.  
  1199.                                     PhoneList = NULL;
  1200.                                 }
  1201.  
  1202.                                 if(NewPhoneEntry())
  1203.                                 {
  1204.                                     struct PhoneEntry *SelectedEntry = SelectedNode -> Entry;
  1205.  
  1206.                                     if(PhoneList = CreatePhoneList())
  1207.                                     {
  1208.                                         struct PhoneNode *Tmp = SelectedEntry -> Node;
  1209.                                         LONG i;
  1210.                                         ULONG ID;
  1211.  
  1212.                                         SelectedNode = (struct PhoneNode *)PhoneList -> lh_TailPred;
  1213.  
  1214.                                         if(PhonebookDefaultGroup)
  1215.                                         {
  1216.                                             PhoneGroupNode *Group;
  1217.  
  1218.                                             Group = (PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName));
  1219.  
  1220.                                             if(AddGroupEntry(Group,SelectedNode))
  1221.                                             {
  1222.                                                 struct PhoneNode *Node;
  1223.  
  1224.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  1225.  
  1226.                                                 for(Selected = 0, Node = (struct PhoneNode *)Group -> GroupList . mlh_Head ; Node -> VanillaNode . ln_Succ ; Node = (struct PhoneNode *)Node -> VanillaNode . ln_Succ)
  1227.                                                 {
  1228.                                                     if(Node == SelectedNode)
  1229.                                                         break;
  1230.                                                     else
  1231.                                                         Selected++;
  1232.                                                 }
  1233.  
  1234.                                                 ListMax++;
  1235.                                             }
  1236.                                             else
  1237.                                             {
  1238.                                                 DisplayBeep(PhoneWindow -> WScreen);
  1239.  
  1240.                                                 PhonebookDefaultGroup = 0;
  1241.  
  1242.                                                 LT_SetAttributes(Manager,GAD_GROUPID,
  1243.                                                     GTCY_Active,0,
  1244.                                                 TAG_DONE);
  1245.  
  1246.                                                 CurrentList = PhoneList;
  1247.                                                 ListMax = NumPhoneEntries;
  1248.                                             }
  1249.                                         }
  1250.                                         else
  1251.                                         {
  1252.                                             CurrentList = PhoneList;
  1253.                                             ListMax++;
  1254.                                             Selected = ListMax - 1;
  1255.                                         }
  1256.  
  1257.                                         ID = SelectedNode -> Entry -> Header -> ID;
  1258.  
  1259.                                         CopyMem(Tmp -> Entry -> Header,SelectedNode -> Entry -> Header,sizeof(struct PhoneHeader));
  1260.  
  1261.                                         SelectedNode -> Entry -> Header -> QuickMenu    = FALSE;
  1262.                                         SelectedNode -> Entry -> Header -> ID            = ID;
  1263.  
  1264.                                         SPrintf(SelectedNode -> LocalName,"      %s",SelectedNode -> Entry -> Header -> Name);
  1265.  
  1266.                                         if(SelectedNode -> Entry -> NodeGroup)
  1267.                                             strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> LocalName);
  1268.  
  1269.                                         FreeTimeDateList((struct List *)&SelectedNode -> Entry -> TimeDateList);
  1270.  
  1271.                                         CopyTimeDateList((struct List *)&Tmp -> Entry -> TimeDateList,(struct List *)&SelectedNode -> Entry -> TimeDateList,FALSE);
  1272.  
  1273.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1274.                                             GTLV_Labels,        CurrentList,
  1275.                                             GTLV_Selected,        Selected,
  1276.                                         TAG_DONE);
  1277.  
  1278.                                             /* Allocate space for the config data. */
  1279.  
  1280.                                         for(i = PREF_SERIAL ; i <= PREF_FASTMACROFILENAME ; i++)
  1281.                                         {
  1282.                                             if(GetConfigEntry(Tmp -> Entry -> Config,i))
  1283.                                                 CreateConfigEntry(SelectedNode -> Entry -> Config,i);
  1284.                                         }
  1285.  
  1286.                                             /* Copy the data. */
  1287.  
  1288.                                         SaveConfig(Tmp -> Entry -> Config,SelectedNode -> Entry -> Config);
  1289.  
  1290.                                         RebuildMenu = PhonebookChanged = TRUE;
  1291.  
  1292.                                         if(!Editor)
  1293.                                         {
  1294.                                             if(Editor = CreateEditorHandle(Manager -> Window,CurrentList,Count,SelectedNode,TRUE,PhoneWindow -> UserPort))
  1295.                                                 EditWindow = Editor -> Window;
  1296.                                         }
  1297.                                         else
  1298.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,TRUE,Hide,TRUE);
  1299.                                     }
  1300.                                     else
  1301.                                         goto ClearList;
  1302.                                 }
  1303.                                 else
  1304.                                     goto ClearList;
  1305.                             }
  1306.  
  1307.                             break;
  1308.  
  1309.                             // Delete the current entry
  1310.  
  1311.                         case GAD_DELETE:
  1312.  
  1313.                             if(SelectedNode)
  1314.                             {
  1315.                                     // We canot delete entries that are still in use by
  1316.                                     // the status server.
  1317.  
  1318.                                 if(SelectedNode -> Entry == ChosenEntry)
  1319.                                     MyEasyRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  1320.                                 else
  1321.                                 {
  1322.                                     struct PhoneNode    *Next;
  1323.                                     struct PhoneEntry    *Entry;
  1324.  
  1325.                                         // Pick the node that will show up as the next
  1326.                                         // selected node.
  1327.  
  1328.                                     if(SelectedNode -> VanillaNode . ln_Succ -> ln_Succ)
  1329.                                         Next = (struct PhoneNode *)SelectedNode -> VanillaNode . ln_Succ;
  1330.                                     else
  1331.                                     {
  1332.                                         if(SelectedNode -> VanillaNode . ln_Pred -> ln_Pred)
  1333.                                             Next = (struct PhoneNode *)SelectedNode -> VanillaNode . ln_Pred;
  1334.                                         else
  1335.                                             Next = NULL;
  1336.                                     }
  1337.  
  1338.                                     if(Next)
  1339.                                         Entry = Next -> Entry;
  1340.                                     else
  1341.                                         Entry = NULL;
  1342.  
  1343.                                         // This is definitely a change
  1344.  
  1345.                                     RebuildMenu = PhonebookChanged = TRUE;
  1346.  
  1347.                                         // Disconnect the list
  1348.  
  1349.                                     LT_SetAttributes(Handle,GAD_NAMELIST,
  1350.                                         GTLV_Labels,~0,
  1351.                                     TAG_DONE);
  1352.  
  1353.                                         // Get rid of it
  1354.  
  1355.                                     if(PhoneList)
  1356.                                     {
  1357.                                         DeletePhoneList(PhoneList);
  1358.  
  1359.                                         PhoneList = NULL;
  1360.                                     }
  1361.  
  1362.                                         // If this particular entry is tagged,
  1363.                                         // untag it first
  1364.  
  1365.                                     if(SelectedNode -> Entry -> Count != -1)
  1366.                                     {
  1367.                                         RemoveDialEntry(SelectedNode);
  1368.  
  1369.                                         Count--;
  1370.  
  1371.                                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1372.                                     }
  1373.  
  1374.                                         // Get rid of the entry
  1375.  
  1376.                                     if(PhonebookDefaultGroup)
  1377.                                         RemPhoneEntry(SelectedNode,0);
  1378.                                     else
  1379.                                         RemPhoneEntry(NULL,Selected);
  1380.  
  1381.                                         // One less in the group...
  1382.  
  1383.                                     ListMax--;
  1384.  
  1385.                                         // Are there still entries left?
  1386.  
  1387.                                     if(NumPhoneEntries > 0)
  1388.                                     {
  1389.                                             // Form a new list
  1390.  
  1391.                                         if(PhoneList = CreatePhoneList())
  1392.                                         {
  1393.                                                 // Move to the next selected entry
  1394.  
  1395.                                             if(PhonebookDefaultGroup)
  1396.                                                 SelectedNode = Next;
  1397.                                             else
  1398.                                             {
  1399.                                                 CurrentList = PhoneList;
  1400.  
  1401.                                                 SelectedNode = Entry -> Node;
  1402.                                             }
  1403.  
  1404.                                                 // Adapt the index
  1405.  
  1406.                                             if(Selected == ListMax)
  1407.                                                 Selected--;
  1408.  
  1409.                                             LT_SetAttributes(Handle,GAD_NAMELIST,
  1410.                                                 GTLV_Labels,    CurrentList,
  1411.                                                 GTLV_Selected,    Selected,
  1412.                                             TAG_DONE);
  1413.  
  1414.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1415.                                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1416.                                         }
  1417.                                         else
  1418.                                             goto ClearList;
  1419.                                     }
  1420.                                     else
  1421.                                     {
  1422. ClearList:                                LT_SetAttributes(Handle,GAD_NAMELIST,
  1423.                                             GTLV_Labels,    NULL,
  1424.                                             GTLV_Selected,    ~0,
  1425.                                         TAG_DONE);
  1426.  
  1427.                                         Selected = ~0;
  1428.                                         SelectedNode = NULL;
  1429.  
  1430.                                         Count = 0;
  1431.                                         ListMax = 0;
  1432.  
  1433.                                         HighlightEntry(Manager,Editor,CurrentList,NULL,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1434.                                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1435.                                     }
  1436.                                 }
  1437.                             }
  1438.  
  1439.                             if(!Count)
  1440.                             {
  1441.                                 LT_DeleteHandle(Grouping);
  1442.  
  1443.                                 Grouping = NULL;
  1444.                                 GroupWindow = NULL;
  1445.                             }
  1446.  
  1447.                             break;
  1448.  
  1449.                             // Change the system name; this is what shows up in the list
  1450.  
  1451.                         case GAD_SYSTEM_NAME:
  1452.  
  1453.                             if(SelectedNode)
  1454.                             {
  1455.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  1456.                                     GTLV_Labels,~0,
  1457.                                 TAG_DONE);
  1458.  
  1459.                                 strcpy(SelectedNode -> Entry -> Header -> Name,(STRPTR)LT_GetAttributes(Editor,GAD_SYSTEM_NAME,TAG_DONE));
  1460.  
  1461.                                 UpdatePhoneList(PhoneList);
  1462.  
  1463.                                 if(!SelectedNode -> Entry -> Header -> Name[0])
  1464.                                 {
  1465.                                     LT_SetAttributes(Manager,GAD_NAMELIST,
  1466.                                         GTLV_Labels,    ~0,
  1467.                                     TAG_DONE);
  1468.  
  1469.                                     if(SelectedNode -> Entry -> Count != -1)
  1470.                                     {
  1471.                                         RemoveDialEntry(SelectedNode);
  1472.  
  1473.                                         Count--;
  1474.  
  1475.                                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1476.                                     }
  1477.                                 }
  1478.  
  1479.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1480.  
  1481.                                 RebuildMenu = PhonebookChanged = TRUE;
  1482.  
  1483.                                 if(MsgCode == '\r')
  1484.                                     LT_Activate(Editor,GAD_COMMENT);
  1485.                             }
  1486.  
  1487.                             break;
  1488.  
  1489.                             // Change the comment; this is what shows up directly below the list
  1490.  
  1491.                         case GAD_COMMENT:
  1492.  
  1493.                             if(SelectedNode)
  1494.                             {
  1495.                                 strcpy(SelectedNode -> Entry -> Header -> Comment,(STRPTR)LT_GetAttributes(Editor,GAD_COMMENT,TAG_DONE));
  1496.  
  1497.                                 PhonebookChanged = TRUE;
  1498.  
  1499.                                 if(MsgCode == '\r')
  1500.                                     LT_Activate(Handle,GAD_NUMBERS);
  1501.  
  1502.                                 LT_SetAttributes(Manager,GAD_COMMENTLINE,
  1503.                                     GTTX_Text,    SelectedNode -> Entry -> Header -> Comment,
  1504.                                 TAG_DONE);
  1505.                             }
  1506.  
  1507.                             break;
  1508.  
  1509.                             // Put this entry into the quick dial menu or don't
  1510.  
  1511.                         case GAD_QUICK_MENU:
  1512.  
  1513.                             if(SelectedNode)
  1514.                             {
  1515.                                 if(SelectedNode -> Entry -> Header -> QuickMenu != MsgCode)
  1516.                                 {
  1517.                                     SelectedNode -> Entry -> Header -> QuickMenu = MsgCode;
  1518.  
  1519.                                     RebuildMenu = PhonebookChanged = TRUE;
  1520.                                 }
  1521.                             }
  1522.  
  1523.                             break;
  1524.  
  1525.                             // Do the same for the autodial feature
  1526.  
  1527.                         case GAD_AUTODIAL:
  1528.  
  1529.                             if(SelectedNode)
  1530.                                 SelectedNode -> Entry -> Header -> AutoDial = MsgCode;
  1531.  
  1532.                             break;
  1533.  
  1534.                             // Change the phone numbers for this entry
  1535.  
  1536.                         case GAD_NUMBERS:
  1537.  
  1538.                             if(SelectedNode)
  1539.                             {
  1540.                                 strcpy(SelectedNode -> Entry -> Header -> Number,(STRPTR)LT_GetAttributes(Editor,GAD_NUMBERS,TAG_DONE));
  1541.  
  1542.                                 PhonebookChanged = TRUE;
  1543.  
  1544.                                 if(!SelectedNode -> Entry -> Header -> Number[0])
  1545.                                 {
  1546.                                     LT_SetAttributes(Manager,GAD_NAMELIST,
  1547.                                         GTLV_Labels,    ~0,
  1548.                                     TAG_DONE);
  1549.  
  1550.                                     if(SelectedNode -> Entry -> Count != -1)
  1551.                                     {
  1552.                                         RemoveDialEntry(SelectedNode);
  1553.  
  1554.                                         Count--;
  1555.                                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1556.                                     }
  1557.                                 }
  1558.  
  1559.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  1560.                             }
  1561.  
  1562.                             break;
  1563.  
  1564.                             // Change the user name
  1565.  
  1566.                         case GAD_USER_NAME:
  1567.  
  1568.                             if(SelectedNode)
  1569.                             {
  1570.                                 strcpy(SelectedNode -> Entry -> Header -> UserName,(STRPTR)LT_GetAttributes(Editor,GAD_USER_NAME,TAG_DONE));
  1571.  
  1572.                                 PhonebookChanged = TRUE;
  1573.                             }
  1574.  
  1575.                             break;
  1576.  
  1577.                             // Change the login password
  1578.  
  1579.                         case GAD_USER_PASSWORD:
  1580.  
  1581.                             if(SelectedNode)
  1582.                             {
  1583.                                 strcpy(SelectedNode -> Entry -> Header -> Password,(STRPTR)LT_GetAttributes(Editor,GAD_USER_PASSWORD,TAG_DONE));
  1584.  
  1585.                                 PhonebookChanged = TRUE;
  1586.                             }
  1587.  
  1588.                             break;
  1589.  
  1590.                             // Load a new phonebook
  1591.  
  1592.                         case GAD_LOAD:
  1593.  
  1594.                             LT_LockWindow(PhoneWindow);
  1595.                             LT_LockWindow(EditWindow);
  1596.                             LT_LockWindow(PatternWindow);
  1597.                             LT_LockWindow(GroupWindow);
  1598.                             LT_LockWindow(SortWindow);
  1599.  
  1600.                                 // If an entry is still in use, don't let the user replace
  1601.                                 // the phonebook
  1602.  
  1603.                             if(ChosenEntry)
  1604.                                 MyEasyRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_LOAD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  1605.                             else
  1606.                             {
  1607.                                 SplitFileName(LastPhone,&DummyChar,DummyBuffer);
  1608.  
  1609.                                 if(FileRequest = GetFile(PhoneWindow,LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT),DummyBuffer,DummyChar,DummyBuffer,"#?.prefs",FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_LOAD_TXT),TRUE))
  1610.                                 {
  1611.                                     STRPTR *OtherLabels;
  1612.  
  1613.                                     LT_SetAttributes(Handle,GAD_NAMELIST,
  1614.                                         GTLV_Labels,    ~0,
  1615.                                     TAG_DONE);
  1616.  
  1617.                                     if(PhoneList)
  1618.                                         DeletePhoneList(PhoneList);
  1619.  
  1620.                                     LT_DeleteHandle(Grouping);
  1621.  
  1622.                                     Grouping = NULL;
  1623.                                     GroupWindow = NULL;
  1624.  
  1625.                                     if(!LoadPhonebook(DummyBuffer,NULL))
  1626.                                         ShowError(PhoneWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  1627.                                     else
  1628.                                     {
  1629.                                         strcpy(LastPhone,DummyBuffer);
  1630.  
  1631.                                         PhonebookChanged = FALSE;
  1632.  
  1633.                                         RebuildMenu = TRUE;
  1634.                                     }
  1635.  
  1636.                                     if(!(PhoneList = CreatePhoneList()))
  1637.                                     {
  1638.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1639.                                             GTLV_Labels,    NULL,
  1640.                                             GA_Disabled,    TRUE,
  1641.                                         TAG_DONE);
  1642.                                     }
  1643.  
  1644.                                     CurrentList = PhoneList;
  1645.                                     ListMax = NumPhoneEntries;
  1646.  
  1647.                                     Selected = ~0;
  1648.                                     SelectedNode = NULL;
  1649.  
  1650.                                     Count = 0;
  1651.  
  1652.                                     FreeAslRequest(FileRequest);
  1653.  
  1654.                                         // The group labels need to be rebuilt. If we run
  1655.                                         // out of memory, access to groups other than the
  1656.                                         // main group will be blocked
  1657.  
  1658.                                     if(OtherLabels = BuildLabels())
  1659.                                     {
  1660.                                         FreeVecPooled(Labels);
  1661.  
  1662.                                         Labels = OtherLabels;
  1663.                                     }
  1664.                                     else
  1665.                                     {
  1666.                                         Labels[1] = NULL;
  1667.  
  1668.                                         PhonebookDefaultGroup = 0;
  1669.                                     }
  1670.  
  1671.                                     if(PhonebookDefaultGroup)
  1672.                                     {
  1673.                                         PhoneGroupNode    *Group;
  1674.                                         struct Node        *Node;
  1675.  
  1676.                                             // Grab the list we wanted
  1677.  
  1678.                                         Group = (PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName));
  1679.  
  1680.                                         LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  1681.                                             GA_Disabled,FALSE,
  1682.                                         TAG_DONE);
  1683.  
  1684.                                         CurrentList = (struct List *)&Group -> GroupList;
  1685.  
  1686.                                         for(ListMax = 0, Node = CurrentList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  1687.                                             ListMax++;
  1688.                                     }
  1689.  
  1690.                                     if(GroupWindow)
  1691.                                         LT_SetAttributes(Grouping,GAD_GROUP_LIST,GTCY_Labels,Labels,TAG_DONE);
  1692.  
  1693.                                     LT_SetAttributes(Manager,GAD_GROUPID,
  1694.                                         GTCY_Labels,    Labels,
  1695.                                         GTCY_Active,    PhonebookDefaultGroup,
  1696.                                     TAG_DONE);
  1697.  
  1698.                                     LT_SetAttributes(Manager,GAD_MAIN_AUTODIAL,
  1699.                                         GTCB_Checked,    PhonebookAutoDial,
  1700.                                     TAG_DONE);
  1701.  
  1702.                                     LT_SetAttributes(Manager,GAD_MAIN_EXIT_WHEN_FINISHED,
  1703.                                         GA_Disabled,    !PhonebookAutoDial,
  1704.                                         GTCB_Checked,    PhonebookAutoExit,
  1705.                                     TAG_DONE);
  1706.  
  1707.                                     if(CurrentList)
  1708.                                     {
  1709.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1710.                                             GTLV_Labels,    CurrentList,
  1711.                                             GA_Disabled,    FALSE,
  1712.                                         TAG_DONE);
  1713.  
  1714.                                         FreeDialList(TRUE);
  1715.                                     }
  1716.  
  1717.                                     HighlightEntry(Manager,Editor,CurrentList,NULL,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  1718.  
  1719.                                     UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1720.                                 }
  1721.                             }
  1722.  
  1723.                             LT_UnlockWindow(PhoneWindow);
  1724.                             LT_UnlockWindow(EditWindow);
  1725.                             LT_UnlockWindow(PatternWindow);
  1726.                             LT_UnlockWindow(GroupWindow);
  1727.                             LT_UnlockWindow(SortWindow);
  1728.  
  1729.                             break;
  1730.  
  1731.                             // Merge existing phonebook with a new phonebook loaded from disk
  1732.  
  1733.                         case GAD_MERGE:
  1734.  
  1735.                             LT_LockWindow(PhoneWindow);
  1736.                             LT_LockWindow(EditWindow);
  1737.                             LT_LockWindow(PatternWindow);
  1738.                             LT_LockWindow(GroupWindow);
  1739.                             LT_LockWindow(SortWindow);
  1740.  
  1741.                             if(ChosenEntry)
  1742.                                 MyEasyRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_LOAD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  1743.                             else
  1744.                             {
  1745.                                 PhonebookHandle BookHandle;
  1746.  
  1747.                                 memset(&BookHandle,0,sizeof(BookHandle));
  1748.  
  1749.                                 memcpy(BookHandle . PhonePassword,PhonePassword,256);
  1750.                                 BookHandle . PhonePasswordUsed = PhonePasswordUsed;
  1751.  
  1752.                                 SplitFileName(LastPhone,&DummyChar,DummyBuffer);
  1753.  
  1754.                                 if(FileRequest = GetFile(PhoneWindow,LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT),DummyBuffer,DummyChar,DummyBuffer,"#?.prefs",FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_LOAD_TXT),TRUE))
  1755.                                 {
  1756.                                     STRPTR *OtherLabels;
  1757.  
  1758.                                     LT_SetAttributes(Handle,GAD_NAMELIST,
  1759.                                         GTLV_Labels,    ~0,
  1760.                                     TAG_DONE);
  1761.  
  1762.                                     if(PhoneList)
  1763.                                         DeletePhoneList(PhoneList);
  1764.  
  1765.                                     if(!LoadPhonebook(DummyBuffer,&BookHandle))
  1766.                                         ShowError(PhoneWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  1767.                                     else
  1768.                                     {
  1769.                                         if(MergePhonebook(&BookHandle))
  1770.                                         {
  1771.                                             strcpy(LastPhone,DummyBuffer);
  1772.  
  1773.                                             PhonebookChanged = RebuildMenu = TRUE;
  1774.                                         }
  1775.                                         else
  1776.                                             DeletePhonebook(BookHandle . Phonebook,BookHandle . PhoneSize,TRUE);
  1777.                                     }
  1778.  
  1779.                                     if(PhoneList = CreatePhoneList())
  1780.                                     {
  1781.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1782.                                             GTLV_Labels,    PhoneList,
  1783.                                             GA_Disabled,    FALSE,
  1784.                                         TAG_DONE);
  1785.  
  1786.                                         FreeDialList(TRUE);
  1787.                                     }
  1788.                                     else
  1789.                                     {
  1790.                                         LT_SetAttributes(Handle,GAD_NAMELIST,
  1791.                                             GTLV_Labels,    NULL,
  1792.                                             GA_Disabled,    TRUE,
  1793.                                         TAG_DONE);
  1794.                                     }
  1795.  
  1796.                                     CurrentList = PhoneList;
  1797.                                     ListMax = NumPhoneEntries;
  1798.  
  1799.                                     Selected = ~0;
  1800.                                     SelectedNode = NULL;
  1801.  
  1802.                                     Count = 0;
  1803.  
  1804.                                     HighlightEntry(Manager,Editor,CurrentList,NULL,Count,PhonebookDefaultGroup = 0,FALSE,Hide,TRUE);
  1805.  
  1806.                                     FreeAslRequest(FileRequest);
  1807.  
  1808.                                     if(OtherLabels = BuildLabels())
  1809.                                     {
  1810.                                         FreeVecPooled(Labels);
  1811.  
  1812.                                         Labels = OtherLabels;
  1813.                                     }
  1814.                                     else
  1815.                                     {
  1816.                                         Labels[1] = NULL;
  1817.  
  1818.                                         PhonebookDefaultGroup = 0;
  1819.                                     }
  1820.  
  1821.                                     if(GroupWindow)
  1822.                                         LT_SetAttributes(Grouping,GAD_GROUP_LIST,GTCY_Labels,Labels,TAG_DONE);
  1823.  
  1824.                                     LT_SetAttributes(Manager,GAD_GROUPID,
  1825.                                         GTCY_Labels,    Labels,
  1826.                                         GTCY_Active,    0,
  1827.                                     TAG_DONE);
  1828.  
  1829.                                     UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  1830.                                 }
  1831.                             }
  1832.  
  1833.                             LT_UnlockWindow(PhoneWindow);
  1834.                             LT_UnlockWindow(EditWindow);
  1835.                             LT_UnlockWindow(PatternWindow);
  1836.                             LT_UnlockWindow(GroupWindow);
  1837.                             LT_UnlockWindow(SortWindow);
  1838.  
  1839.                             break;
  1840.  
  1841.                             // Join the currently tagged entries in a new group
  1842.  
  1843.                         case GAD_MAKE_GROUP:
  1844.  
  1845.                             if(GroupWindow)
  1846.                             {
  1847.                                 LT_ShowWindow(Grouping,TRUE);
  1848.                                 LT_Activate(Grouping,GAD_GROUP_NAME);
  1849.                             }
  1850.                             else
  1851.                             {
  1852.                                 if(Grouping = CreateGroupHandle(PhoneWindow,Labels,PhonebookDefaultGroup))
  1853.                                     GroupWindow = Grouping -> Window;
  1854.                             }
  1855.  
  1856.                             break;
  1857.  
  1858.                             // Copy the selected group name into the text entry field
  1859.  
  1860.                         case GAD_GROUP_LIST:
  1861.  
  1862.                             LT_SetAttributes(Grouping,GAD_GROUP_NAME,
  1863.                                 GTST_String,    Labels[MsgCode],
  1864.                             TAG_DONE);
  1865.  
  1866.                             break;
  1867.  
  1868.                             // Do something to the selected entries.
  1869.  
  1870.                         case GAD_GROUP_OK:
  1871.  
  1872.                             LT_LockWindow(PhoneWindow);
  1873.                             LT_LockWindow(EditWindow);
  1874.                             LT_LockWindow(PatternWindow);
  1875.                             LT_LockWindow(GroupWindow);
  1876.                             LT_LockWindow(SortWindow);
  1877.  
  1878.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  1879.                                 GTLV_Labels,    ~0,
  1880.                             TAG_DONE);
  1881.  
  1882.                                 // Which group should the tagged entries go into?
  1883.  
  1884.                             Name = (STRPTR)LT_GetAttributes(Grouping,GAD_GROUP_NAME,TAG_DONE);
  1885.  
  1886.                                 // If it's "All", then the entries will be removed from the
  1887.                                 // subgroups and end up in the main group
  1888.  
  1889.                             if(!Stricmp(Name,Labels[0]))
  1890.                             {
  1891.                                 struct PhoneNode *Next;
  1892.  
  1893.                                 for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; Next = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ ; TempNode = Next)
  1894.                                 {
  1895.                                     if(TempNode -> Entry -> ThisGroup && TempNode -> Entry -> Count != -1)
  1896.                                     {
  1897.                                         Remove(TempNode -> Entry -> NodeGroup);
  1898.  
  1899.                                         FreeVecPooled(TempNode -> Entry -> NodeGroup);
  1900.  
  1901.                                         TempNode -> Entry -> ThisGroup = NULL;
  1902.                                         TempNode -> Entry -> NodeGroup = NULL;
  1903.                                     }
  1904.                                 }
  1905.                             }
  1906.                             else
  1907.                             {
  1908.                                 PhoneGroupNode    *GroupNode;
  1909.                                 PhoneGroupNode    *WhichGroup        = NULL;
  1910.                                 BOOL             RenameGroup    = TRUE,
  1911.                                                  Success        = TRUE;
  1912.  
  1913.                                     // Check if the requested group already exists. In this
  1914.                                     // case, the user wants to move entries from one group
  1915.                                     // to another.
  1916.  
  1917.                                 for(GroupNode = (PhoneGroupNode *)PhoneGroupList . mlh_Head ; GroupNode -> Node . ln_Succ ; GroupNode = (PhoneGroupNode *)GroupNode -> Node . ln_Succ)
  1918.                                 {
  1919.                                     if(!Stricmp(GroupNode -> Node . ln_Name,Name))
  1920.                                     {
  1921.                                         RenameGroup = FALSE;
  1922.                                         break;
  1923.                                     }
  1924.                                 }
  1925.  
  1926.                                     // Check if the marked entries are already
  1927.                                     // members of the same group
  1928.  
  1929.                                 if(RenameGroup)
  1930.                                 {
  1931.                                     LONG i,NotGrouped = 0;
  1932.  
  1933.                                     for(i = 0 ; RenameGroup && i < NumPhoneEntries ; i++)
  1934.                                     {
  1935.                                         if(Phonebook[i] -> Count != -1)
  1936.                                         {
  1937.                                             if(Phonebook[i] -> ThisGroup)
  1938.                                             {
  1939.                                                 if(NotGrouped)
  1940.                                                     RenameGroup = FALSE;
  1941.                                                 else
  1942.                                                 {
  1943.                                                     if(!WhichGroup)
  1944.                                                         WhichGroup = Phonebook[i] -> ThisGroup;
  1945.                                                     else
  1946.                                                     {
  1947.                                                         if(Phonebook[i] -> ThisGroup != WhichGroup)
  1948.                                                             RenameGroup = FALSE;
  1949.                                                     }
  1950.                                                 }
  1951.                                             }
  1952.                                             else
  1953.                                             {
  1954.                                                 if(WhichGroup)
  1955.                                                     RenameGroup = FALSE;
  1956.                                                 else
  1957.                                                     NotGrouped++;
  1958.                                             }
  1959.                                         }
  1960.                                     }
  1961.  
  1962.                                         // If we should continue, check if there are
  1963.                                         // any group members at all.
  1964.  
  1965.                                     if(RenameGroup && !NotGrouped && WhichGroup)
  1966.                                     {
  1967.                                         LONG Tagged = 0;
  1968.  
  1969.                                         for(i = 0 ; i < NumPhoneEntries ; i++)
  1970.                                         {
  1971.                                             if(Phonebook[i] -> Count != -1 && Phonebook[i] -> ThisGroup == WhichGroup)
  1972.                                                 Tagged++;
  1973.                                         }
  1974.  
  1975.                                             // Did all the group members get tagged?
  1976.  
  1977.                                         if(Tagged != Count)
  1978.                                             RenameGroup = FALSE;
  1979.                                     }
  1980.                                     else
  1981.                                         RenameGroup = FALSE;
  1982.                                 }
  1983.  
  1984.                                 if(RenameGroup)
  1985.                                 {
  1986.                                     strcpy(WhichGroup -> LocalName,Name);
  1987.  
  1988.                                     GroupNode = WhichGroup;
  1989.                                 }
  1990.                                 else
  1991.                                 {
  1992.                                         // Either find an existing group of the given name
  1993.                                         // or make a new group.
  1994.  
  1995.                                     if(GroupNode = CreatePhoneGroup(Name,&PhoneGroupList))
  1996.                                     {
  1997.                                         struct PhoneNode    *Next;
  1998.                                         LONG                 Total = 0;
  1999.  
  2000.                                             // Add the tagged entries to the group
  2001.  
  2002.                                         for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; Next = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ ; TempNode = Next)
  2003.                                         {
  2004.                                             if(TempNode -> Entry -> Count != -1)
  2005.                                             {
  2006.                                                 AddGroupEntry(GroupNode,TempNode);
  2007.                                                 Total++;
  2008.                                             }
  2009.                                         }
  2010.  
  2011.                                         if(!Total && SelectedNode)
  2012.                                             AddGroupEntry(GroupNode,SelectedNode);
  2013.                                     }
  2014.                                     else
  2015.                                         Success = FALSE;
  2016.                                 }
  2017.  
  2018.                                 if(Success)
  2019.                                 {
  2020.                                     STRPTR *OtherLabels;
  2021.  
  2022.                                         // Now update the labels
  2023.  
  2024.                                     if(OtherLabels = BuildLabels())
  2025.                                     {
  2026.                                         PhoneGroupNode *This;
  2027.  
  2028.                                         FreeVecPooled(Labels);
  2029.  
  2030.                                         Labels = OtherLabels;
  2031.  
  2032.                                         CurrentList = (struct List *)&GroupNode -> GroupList;
  2033.  
  2034.                                         for(PhonebookDefaultGroup = 1, This = (PhoneGroupNode *)PhoneGroupList . mlh_Head ; This -> Node . ln_Succ ; This = (PhoneGroupNode *)This -> Node . ln_Succ)
  2035.                                         {
  2036.                                             if(This == GroupNode)
  2037.                                                 break;
  2038.                                             else
  2039.                                                 PhonebookDefaultGroup++;
  2040.                                         }
  2041.                                     }
  2042.                                     else
  2043.                                     {
  2044.                                         Labels[1] = NULL;
  2045.  
  2046.                                         PhonebookDefaultGroup = 0;
  2047.  
  2048.                                         CurrentList = PhoneList;
  2049.                                         ListMax = NumPhoneEntries;
  2050.                                     }
  2051.  
  2052.                                     if(GroupWindow)
  2053.                                     {
  2054.                                         LT_SetAttributes(Grouping,GAD_GROUP_LIST,
  2055.                                             GTCY_Labels,    Labels,
  2056.                                             GTCY_Active,    PhonebookDefaultGroup,
  2057.                                         TAG_DONE);
  2058.                                     }
  2059.  
  2060.                                     LT_SetAttributes(Manager,GAD_GROUPID,
  2061.                                         GTCY_Labels,    Labels,
  2062.                                         GTCY_Active,    PhonebookDefaultGroup,
  2063.                                     TAG_DONE);
  2064.  
  2065.                                     RebuildMenu = PhonebookChanged = TRUE;
  2066.                                 }
  2067.                                 else
  2068.                                     DisplayBeep(PhoneWindow -> WScreen);
  2069.                             }
  2070.  
  2071.                             Selected = ~0;
  2072.                             SelectedNode = NULL;
  2073.  
  2074.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2075.  
  2076.                             LT_UnlockWindow(PhoneWindow);
  2077.                             LT_UnlockWindow(EditWindow);
  2078.                             LT_UnlockWindow(PatternWindow);
  2079.                             LT_UnlockWindow(GroupWindow);
  2080.                             LT_UnlockWindow(SortWindow);
  2081.  
  2082.                             // Close the grouping window without doing anything
  2083.  
  2084.                         case GAD_GROUP_CANCEL:
  2085.  
  2086.                             LT_DeleteHandle(Grouping);
  2087.  
  2088.                             Grouping = NULL;
  2089.                             GroupWindow = NULL;
  2090.  
  2091.                             LT_ShowWindow(Manager,TRUE);
  2092.  
  2093.                             break;
  2094.  
  2095.                             // Display a different group
  2096.  
  2097.                         case GAD_GROUPID:
  2098.  
  2099.                             Selected = ~0;
  2100.                             SelectedNode = NULL;
  2101.  
  2102.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2103.                                 GTLV_Selected,    ~0,
  2104.                             TAG_DONE);
  2105.  
  2106.                                 // Special group?
  2107.  
  2108.                             if(MsgCode)
  2109.                             {
  2110.                                 PhoneGroupNode    *Group;
  2111.                                 struct Node        *Node;
  2112.  
  2113.                                     // Grab the list we wanted
  2114.  
  2115.                                 Group = (PhoneGroupNode *)(((ULONG)Labels[MsgCode]) - offsetof(PhoneGroupNode,LocalName));
  2116.  
  2117.                                 LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  2118.                                     GA_Disabled,FALSE,
  2119.                                 TAG_DONE);
  2120.  
  2121.                                 CurrentList = (struct List *)&Group -> GroupList;
  2122.  
  2123.                                 for(ListMax = 0, Node = CurrentList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  2124.                                     ListMax++;
  2125.                             }
  2126.                             else
  2127.                             {
  2128.                                 LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  2129.                                     GA_Disabled,TRUE,
  2130.                                 TAG_DONE);
  2131.  
  2132.                                 CurrentList    = PhoneList;
  2133.                                 ListMax        = NumPhoneEntries;
  2134.                             }
  2135.  
  2136.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2137.                                 GTLV_Labels,CurrentList,
  2138.                             TAG_DONE);
  2139.  
  2140.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2141.  
  2142.                             break;
  2143.  
  2144.                             // Get rid of this group
  2145.  
  2146.                         case GAD_SPLIT_GROUP:
  2147.  
  2148.                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2149.                                 GTLV_Labels,~0,
  2150.                             TAG_DONE);
  2151.  
  2152.                             LT_DeleteHandle(Grouping);
  2153.  
  2154.                             Grouping = NULL;
  2155.                             GroupWindow = NULL;
  2156.  
  2157.                             Remove((struct Node *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName)));
  2158.  
  2159.                             DeletePhoneGroupNode((PhoneGroupNode *)(((ULONG)Labels[PhonebookDefaultGroup]) - offsetof(PhoneGroupNode,LocalName)));
  2160.  
  2161.                             CurrentList = PhoneList;
  2162.                             ListMax = NumPhoneEntries;
  2163.                             Selected = ~0;
  2164.                             SelectedNode = NULL;
  2165.                             PhonebookDefaultGroup = 0;
  2166.  
  2167.                                 // Now update the labels
  2168.  
  2169.                             if(OtherLabels = BuildLabels())
  2170.                             {
  2171.                                 FreeVecPooled(Labels);
  2172.  
  2173.                                 Labels = OtherLabels;
  2174.                             }
  2175.  
  2176.                             if(GroupWindow)
  2177.                                 LT_SetAttributes(Grouping,GAD_GROUP_LIST,GTCY_Labels,Labels,TAG_DONE);
  2178.  
  2179.                             LT_SetAttributes(Manager,GAD_GROUPID,GTCY_Labels,Labels,TAG_DONE);
  2180.  
  2181.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2182.  
  2183.                             PhonebookChanged = TRUE;
  2184.  
  2185.                             break;
  2186.  
  2187.                             // Open the sort window
  2188.  
  2189.                         case GAD_SORT:
  2190.  
  2191.                             if(Sorting)
  2192.                                 LT_ShowWindow(Sorting,TRUE);
  2193.                             else
  2194.                             {
  2195.                                 if(Sorting = CreateSortHandle(PhoneWindow,&Sorter,&ReverseOrder))
  2196.                                     SortWindow = Sorting -> Window;
  2197.                                 else
  2198.                                     DisplayBeep(SortWindow -> WScreen);
  2199.                             }
  2200.  
  2201.                             break;
  2202.  
  2203.                             // Sort the phonelist
  2204.  
  2205.                         case GAD_SORT_AND_CLOSE:
  2206.                         case GAD_SORT_IT:
  2207.  
  2208.                             if(ListMax > 1)
  2209.                             {
  2210.                                 RebuildMenu = PhonebookChanged = TRUE;
  2211.  
  2212.                                 LT_LockWindow(PhoneWindow);
  2213.                                 LT_LockWindow(EditWindow);
  2214.                                 LT_LockWindow(PatternWindow);
  2215.                                 LT_LockWindow(GroupWindow);
  2216.                                 LT_LockWindow(SortWindow);
  2217.  
  2218.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2219.                                     GTLV_Labels,    ~0,
  2220.                                 TAG_DONE);
  2221.  
  2222.                                 SortPhoneEntries(PhonebookDefaultGroup ? CurrentList : NULL,Sorter,ReverseOrder);
  2223.  
  2224.                                 if(!PhonebookDefaultGroup)
  2225.                                     UpdatePhoneList(PhoneList);
  2226.  
  2227.                                 Selected = ~0;
  2228.                                 SelectedNode = NULL;
  2229.  
  2230.                                 HighlightEntry(Manager,Editor,CurrentList,NULL,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2231.  
  2232.                                 LT_UnlockWindow(PhoneWindow);
  2233.                                 LT_UnlockWindow(EditWindow);
  2234.                                 LT_UnlockWindow(PatternWindow);
  2235.                                 LT_UnlockWindow(GroupWindow);
  2236.                                 LT_UnlockWindow(SortWindow);
  2237.                             }
  2238.  
  2239.                             if(MsgGadgetID == GAD_SORT_IT)
  2240.                                 break;
  2241.  
  2242.                             // Falls through to...
  2243.  
  2244.                         case GAD_SORT_JUST_CLOSE:
  2245.  
  2246.                             LT_DeleteHandle(Sorting);
  2247.                             Sorting = NULL;
  2248.                             SortWindow = NULL;
  2249.  
  2250.                             LT_ShowWindow(Manager,TRUE);
  2251.                             break;
  2252.  
  2253.                             // Save the phonebook to disk
  2254.  
  2255.                         case GAD_SAVE:
  2256.  
  2257.                             if(NumPhoneEntries)
  2258.                             {
  2259.                                 SplitFileName(LastPhone,&DummyChar,DummyBuffer);
  2260.  
  2261.                                 LT_LockWindow(PhoneWindow);
  2262.                                 LT_LockWindow(EditWindow);
  2263.                                 LT_LockWindow(PatternWindow);
  2264.                                 LT_LockWindow(GroupWindow);
  2265.                                 LT_LockWindow(SortWindow);
  2266.  
  2267.                                 if(FileRequest = GetFile(PhoneWindow,LocaleString(MSG_PHONEPANEL_SAVE_PHONEBOOK_TXT),DummyBuffer,DummyChar,DummyBuffer,"#?.prefs",TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SAVE_TXT),TRUE))
  2268.                                 {
  2269.                                     if(!SavePhonebook(DummyBuffer))
  2270.                                         ShowError(PhoneWindow,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  2271.                                     else
  2272.                                     {
  2273.                                         strcpy(LastPhone,DummyBuffer);
  2274.  
  2275.                                         PhonebookChanged = FALSE;
  2276.                                     }
  2277.  
  2278.                                     FreeAslRequest(FileRequest);
  2279.                                 }
  2280.  
  2281.                                 LT_UnlockWindow(PhoneWindow);
  2282.                                 LT_UnlockWindow(EditWindow);
  2283.                                 LT_UnlockWindow(PatternWindow);
  2284.                                 LT_UnlockWindow(GroupWindow);
  2285.                                 LT_UnlockWindow(SortWindow);
  2286.                             }
  2287.  
  2288.                             break;
  2289.  
  2290.                             // Copy cofiguration data around
  2291.  
  2292.                         case GAD_COPY_CONFIG:
  2293.                         {
  2294.                             BOOLEAN Changes;
  2295.  
  2296.                             LT_LockWindow(PhoneWindow);
  2297.                             LT_LockWindow(EditWindow);
  2298.                             LT_LockWindow(PatternWindow);
  2299.                             LT_LockWindow(GroupWindow);
  2300.                             LT_LockWindow(SortWindow);
  2301.  
  2302.                             if(!SelectedNode)
  2303.                                 Changes = CopyPanel(PhoneWindow,NULL,Count > 0);
  2304.                             else
  2305.                                 Changes = CopyPanel(PhoneWindow,SelectedNode -> Entry -> Config,Count > 0);
  2306.  
  2307.                             if(Changes)
  2308.                             {
  2309.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2310.  
  2311.                                 PhonebookChanged = TRUE;
  2312.                             }
  2313.  
  2314.                             LT_UnlockWindow(PhoneWindow);
  2315.                             LT_UnlockWindow(EditWindow);
  2316.                             LT_UnlockWindow(PatternWindow);
  2317.                             LT_UnlockWindow(GroupWindow);
  2318.                             LT_UnlockWindow(SortWindow);
  2319.  
  2320.                             LT_ShowWindow(Handle,TRUE);
  2321.  
  2322.                             break;
  2323.                         }
  2324.  
  2325.                             // Change or clear the password
  2326.  
  2327.                         case GAD_PASSWORD:
  2328.                         {
  2329.                             UBYTE SomeBuffer[30];
  2330.  
  2331.                             memset(SomeBuffer,0,21);
  2332.  
  2333.                             PhonePasswordUsed = FALSE;
  2334.  
  2335.                             LT_LockWindow(PhoneWindow);
  2336.                             LT_LockWindow(EditWindow);
  2337.                             LT_LockWindow(PatternWindow);
  2338.                             LT_LockWindow(GroupWindow);
  2339.                             LT_LockWindow(SortWindow);
  2340.  
  2341.                             if(GetString(FALSE,TRUE,21,LocaleString(MSG_PHONEPANEL_PLEASE_ENTER_PASSWORD_TXT),SomeBuffer))
  2342.                             {
  2343.                                 SomeBuffer[20] = 0;
  2344.  
  2345.                                 PhonebookChanged = TRUE;
  2346.  
  2347.                                 if(SomeBuffer[0])
  2348.                                 {
  2349.                                     UBYTE OtherBuffer[30];
  2350.  
  2351.                                     memset(OtherBuffer,0,21);
  2352.  
  2353.                                     if(GetString(FALSE,TRUE,21,LocaleString(MSG_PHONEPANEL_PLEASE_REPEAT_PASSWORD_TXT),OtherBuffer))
  2354.                                     {
  2355.                                         OtherBuffer[20] = 0;
  2356.  
  2357.                                         if(!memcmp(OtherBuffer,SomeBuffer,20))
  2358.                                         {
  2359.                                             Encrypt(OtherBuffer,20,PhonePassword,OtherBuffer,strlen(OtherBuffer));
  2360.  
  2361.                                             PhonePasswordUsed = TRUE;
  2362.                                         }
  2363.                                         else
  2364.                                             MyEasyRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_ERROR_ENTERING_PASSWORD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  2365.                                     }
  2366.                                     else
  2367.                                         MyEasyRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_ERROR_ENTERING_PASSWORD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  2368.                                 }
  2369.                             }
  2370.  
  2371.                             LT_ShowWindow(Handle,TRUE);
  2372.  
  2373.                             LT_UnlockWindow(PhoneWindow);
  2374.                             LT_UnlockWindow(EditWindow);
  2375.                             LT_UnlockWindow(PatternWindow);
  2376.                             LT_UnlockWindow(GroupWindow);
  2377.                             LT_UnlockWindow(SortWindow);
  2378.  
  2379.                             break;
  2380.                         }
  2381.  
  2382.                             // Close the editor window
  2383.  
  2384.                         case GAD_CLOSE:
  2385.  
  2386.                             LT_DeleteHandle(Editor);
  2387.  
  2388.                             Editor = NULL;
  2389.                             EditWindow = NULL;
  2390.  
  2391.                             LT_ShowWindow(Manager,TRUE);
  2392.                             break;
  2393.  
  2394.                             // Move to the first tagged entry
  2395.  
  2396.                         case GAD_FIRST_ENTRY:
  2397.  
  2398.                             if(SelectedNode)
  2399.                             {
  2400.                                 if(SelectedNode -> Entry -> Count > 0)
  2401.                                 {
  2402.                                     LONG i;
  2403.  
  2404.                                     for(i = 0 ; i < NumPhoneEntries ; i++)
  2405.                                     {
  2406.                                         if(!Phonebook[i] -> Node -> Entry -> Count)
  2407.                                         {
  2408.                                             Selected = i;
  2409.                                             SelectedNode = Phonebook[Selected] -> Node;
  2410.  
  2411.                                             if(SelectedNode -> Entry -> NodeGroup)
  2412.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  2413.  
  2414.                                             FindGroup(&CurrentList,&Selected,&PhonebookDefaultGroup,PhoneList,&PhoneGroupList,SelectedNode);
  2415.  
  2416.                                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2417.                                                 GTLV_Labels,    CurrentList,
  2418.                                                 GTLV_Selected,    Selected,
  2419.                                             TAG_DONE);
  2420.  
  2421.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2422.  
  2423.                                             break;
  2424.                                         }
  2425.                                     }
  2426.                                 }
  2427.                             }
  2428.  
  2429.                             break;
  2430.  
  2431.                             // Move to the previous tagged entry
  2432.  
  2433.                         case GAD_PREVIOUS_ENTRY:
  2434.  
  2435.                             if(SelectedNode)
  2436.                             {
  2437.                                 if(SelectedNode -> Entry -> Count > 0)
  2438.                                 {
  2439.                                     LONG i,Index = SelectedNode -> Entry -> Count - 1;
  2440.  
  2441.                                     for(i = 0 ; i < NumPhoneEntries ; i++)
  2442.                                     {
  2443.                                         if(Phonebook[i] -> Node -> Entry -> Count == Index)
  2444.                                         {
  2445.                                             Selected = i;
  2446.                                             SelectedNode = Phonebook[Selected] -> Node;
  2447.  
  2448.                                             if(SelectedNode -> Entry -> NodeGroup)
  2449.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  2450.  
  2451.                                             FindGroup(&CurrentList,&Selected,&PhonebookDefaultGroup,PhoneList,&PhoneGroupList,SelectedNode);
  2452.  
  2453.                                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2454.                                                 GTLV_Labels,    CurrentList,
  2455.                                                 GTLV_Selected,    Selected,
  2456.                                             TAG_DONE);
  2457.  
  2458.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2459.  
  2460.                                             break;
  2461.                                         }
  2462.                                     }
  2463.                                 }
  2464.                             }
  2465.  
  2466.                             break;
  2467.  
  2468.                             // Move to the next tagged entry
  2469.  
  2470.                         case GAD_NEXT_ENTRY:
  2471.  
  2472.                             if(SelectedNode)
  2473.                             {
  2474.                                 if(SelectedNode -> Entry -> Count < Count - 1)
  2475.                                 {
  2476.                                     LONG i,Index = SelectedNode -> Entry -> Count + 1;
  2477.  
  2478.                                     for(i = 0 ; i < NumPhoneEntries ; i++)
  2479.                                     {
  2480.                                         if(Phonebook[i] -> Node -> Entry -> Count == Index)
  2481.                                         {
  2482.                                             Selected = i;
  2483.                                             SelectedNode = Phonebook[Selected] -> Node;
  2484.  
  2485.                                             if(SelectedNode -> Entry -> NodeGroup)
  2486.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  2487.  
  2488.                                             FindGroup(&CurrentList,&Selected,&PhonebookDefaultGroup,PhoneList,&PhoneGroupList,SelectedNode);
  2489.  
  2490.                                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2491.                                                 GTLV_Labels,    CurrentList,
  2492.                                                 GTLV_Selected,    Selected,
  2493.                                             TAG_DONE);
  2494.  
  2495.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2496.  
  2497.                                             break;
  2498.                                         }
  2499.                                     }
  2500.                                 }
  2501.                             }
  2502.  
  2503.                             break;
  2504.  
  2505.                             // Move to the next tagged entry
  2506.  
  2507.                         case GAD_LAST_ENTRY:
  2508.  
  2509.                             if(SelectedNode)
  2510.                             {
  2511.                                 if(SelectedNode -> Entry -> Count < Count - 1)
  2512.                                 {
  2513.                                     LONG i;
  2514.  
  2515.                                     for(i = 0 ; i < NumPhoneEntries ; i++)
  2516.                                     {
  2517.                                         if(Phonebook[i] -> Node -> Entry -> Count == Count - 1)
  2518.                                         {
  2519.                                             Selected = i;
  2520.                                             SelectedNode = Phonebook[Selected] -> Node;
  2521.  
  2522.                                             if(SelectedNode -> Entry -> NodeGroup)
  2523.                                                 SelectedNode = SelectedNode -> Entry -> NodeGroup;
  2524.  
  2525.                                             FindGroup(&CurrentList,&Selected,&PhonebookDefaultGroup,PhoneList,&PhoneGroupList,SelectedNode);
  2526.  
  2527.                                             LT_SetAttributes(Manager,GAD_NAMELIST,
  2528.                                                 GTLV_Labels,    CurrentList,
  2529.                                                 GTLV_Selected,    Selected,
  2530.                                             TAG_DONE);
  2531.  
  2532.                                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2533.  
  2534.                                             break;
  2535.                                         }
  2536.                                     }
  2537.                                 }
  2538.                             }
  2539.  
  2540.                             break;
  2541.  
  2542.                             // Move entry to beginning of list
  2543.  
  2544.                         case GAD_MOVE_FIRST:
  2545.  
  2546.                             if(Selected != ~0 && Selected > 0)
  2547.                             {
  2548.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2549.                                     GTLV_Labels,~0,
  2550.                                 TAG_DONE);
  2551.  
  2552.                                 if(PhonebookDefaultGroup)
  2553.                                 {
  2554.                                     Remove((struct Node *)SelectedNode);
  2555.                                     AddHead(CurrentList,(struct Node *)SelectedNode);
  2556.  
  2557.                                     Selected = 0;
  2558.                                 }
  2559.                                 else
  2560.                                 {
  2561.                                     struct PhoneEntry    *This;
  2562.                                     LONG                 i;
  2563.  
  2564.                                     This = Phonebook[Selected];
  2565.  
  2566.                                     for(i = Selected ; i > 0 ; i--)
  2567.                                         Phonebook[i] = Phonebook[i - 1];
  2568.  
  2569.                                     Phonebook[0] = This;
  2570.  
  2571.                                     UpdatePhoneList(PhoneList);
  2572.  
  2573.                                     Selected = 0;
  2574.                                     SelectedNode = Phonebook[Selected] -> Node;
  2575.                                 }
  2576.  
  2577.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2578.  
  2579.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2580.                                     GTLV_Labels,        CurrentList,
  2581.                                     GTLV_Selected,        Selected,
  2582.                                 TAG_DONE);
  2583.                             }
  2584.  
  2585.                             break;
  2586.  
  2587.                             // Move entry up in the list
  2588.  
  2589.                         case GAD_MOVE_UP:
  2590.  
  2591.                             if(Selected != ~0 && Selected > 0)
  2592.                             {
  2593.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2594.                                     GTLV_Labels,~0,
  2595.                                 TAG_DONE);
  2596.  
  2597.                                 if(PhonebookDefaultGroup)
  2598.                                 {
  2599.                                     struct Node *Other;
  2600.  
  2601.                                     Other = SelectedNode -> VanillaNode . ln_Pred -> ln_Pred;
  2602.  
  2603.                                     Remove((struct Node *)SelectedNode);
  2604.                                     Insert(CurrentList,(struct Node *)SelectedNode,Other);
  2605.  
  2606.                                     Selected--;
  2607.                                 }
  2608.                                 else
  2609.                                 {
  2610.                                     struct PhoneEntry *This;
  2611.  
  2612.                                     This                    = Phonebook[Selected];
  2613.                                     Phonebook[Selected]        = Phonebook[Selected - 1];
  2614.                                     Phonebook[Selected - 1]    = This;
  2615.  
  2616.                                     UpdatePhoneList(PhoneList);
  2617.  
  2618.                                     Selected--;
  2619.                                     SelectedNode = Phonebook[Selected] -> Node;
  2620.                                 }
  2621.  
  2622.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2623.  
  2624.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2625.                                     GTLV_Labels,        CurrentList,
  2626.                                     GTLV_Selected,        Selected,
  2627.                                 TAG_DONE);
  2628.                             }
  2629.  
  2630.                             break;
  2631.  
  2632.                             // Move entry down in the list
  2633.  
  2634.                         case GAD_MOVE_DOWN:
  2635.  
  2636.                             if(Selected != ~0 && Selected < ListMax - 1)
  2637.                             {
  2638.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2639.                                     GTLV_Labels,~0,
  2640.                                 TAG_DONE);
  2641.  
  2642.                                 if(PhonebookDefaultGroup)
  2643.                                 {
  2644.                                     struct Node *Other;
  2645.  
  2646.                                     Other = SelectedNode -> VanillaNode . ln_Succ;
  2647.  
  2648.                                     Remove((struct Node *)SelectedNode);
  2649.                                     Insert(CurrentList,(struct Node *)SelectedNode,Other);
  2650.  
  2651.                                     Selected++;
  2652.                                 }
  2653.                                 else
  2654.                                 {
  2655.                                     struct PhoneEntry *This;
  2656.  
  2657.                                     This                    = Phonebook[Selected];
  2658.                                     Phonebook[Selected]        = Phonebook[Selected + 1];
  2659.                                     Phonebook[Selected + 1]    = This;
  2660.  
  2661.                                     UpdatePhoneList(PhoneList);
  2662.  
  2663.                                     Selected++;
  2664.                                     SelectedNode = Phonebook[Selected] -> Node;
  2665.                                 }
  2666.  
  2667.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2668.  
  2669.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2670.                                     GTLV_Labels,        CurrentList,
  2671.                                     GTLV_Selected,        Selected,
  2672.                                 TAG_DONE);
  2673.                             }
  2674.  
  2675.                             break;
  2676.  
  2677.                             // Move entry to end of list
  2678.  
  2679.                         case GAD_MOVE_LAST:
  2680.  
  2681.                             if(Selected != ~0 && Selected < ListMax - 1)
  2682.                             {
  2683.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2684.                                     GTLV_Labels,~0,
  2685.                                 TAG_DONE);
  2686.  
  2687.                                 if(PhonebookDefaultGroup)
  2688.                                 {
  2689.                                     Remove((struct Node *)SelectedNode);
  2690.                                     AddTail(CurrentList,(struct Node *)SelectedNode);
  2691.  
  2692.                                     Selected = ListMax - 1;
  2693.                                 }
  2694.                                 else
  2695.                                 {
  2696.                                     struct PhoneEntry    *This;
  2697.                                     LONG                 i;
  2698.  
  2699.                                     This = Phonebook[Selected];
  2700.  
  2701.                                     for(i = Selected ; i < NumPhoneEntries - 1 ; i++)
  2702.                                         Phonebook[i] = Phonebook[i + 1];
  2703.  
  2704.                                     Phonebook[NumPhoneEntries - 1] = This;
  2705.  
  2706.                                     UpdatePhoneList(PhoneList);
  2707.  
  2708.                                     Selected = ListMax - 1;
  2709.                                     SelectedNode = Phonebook[Selected] -> Node;
  2710.                                 }
  2711.  
  2712.                                 HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2713.  
  2714.                                 LT_SetAttributes(Manager,GAD_NAMELIST,
  2715.                                     GTLV_Labels,        CurrentList,
  2716.                                     GTLV_Selected,        Selected,
  2717.                                 TAG_DONE);
  2718.                             }
  2719.  
  2720.                             break;
  2721.  
  2722.                             // Fiddle with the editor checkboxes
  2723.  
  2724.                         case GAD_SERIAL_STATE:
  2725.                         case GAD_MODEM_STATE:
  2726.                         case GAD_SCREEN_STATE:
  2727.                         case GAD_TERMINAL_STATE:
  2728.                         case GAD_EMULATION_STATE:
  2729.                         case GAD_CLIPBOARD_STATE:
  2730.                         case GAD_CAPTURE_STATE:
  2731.                         case GAD_COMMAND_STATE:
  2732.                         case GAD_MISC_STATE:
  2733.                         case GAD_PATH_STATE:
  2734.                         case GAD_TRANSFER_STATE:
  2735.                         case GAD_TRANSLATION_STATE:
  2736.                         case GAD_MACRO_STATE:
  2737.                         case GAD_CURSOR_STATE:
  2738.                         case GAD_FASTMACRO_STATE:
  2739.                         case GAD_RATE_STATE:
  2740.  
  2741.                             if(Selected != ~0)
  2742.                             {
  2743.                                 if(ChangeState(MsgGadgetID,MsgCode,SelectedNode))
  2744.                                 {
  2745.                                     HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2746.  
  2747.                                     PhonebookChanged = TRUE;
  2748.                                 }
  2749.                             }
  2750.  
  2751.                             break;
  2752.  
  2753.                             // Edit the settings of the current entry
  2754.  
  2755.                         case GAD_SERIAL_EDIT:
  2756.                         case GAD_MODEM_EDIT:
  2757.                         case GAD_SCREEN_EDIT:
  2758.                         case GAD_TERMINAL_EDIT:
  2759.                         case GAD_EMULATION_EDIT:
  2760.                         case GAD_CLIPBOARD_EDIT:
  2761.                         case GAD_CAPTURE_EDIT:
  2762.                         case GAD_COMMAND_EDIT:
  2763.                         case GAD_MISC_EDIT:
  2764.                         case GAD_PATH_EDIT:
  2765.                         case GAD_TRANSFER_EDIT:
  2766.                         case GAD_TRANSLATION_EDIT:
  2767.                         case GAD_MACRO_EDIT:
  2768.                         case GAD_CURSOR_EDIT:
  2769.                         case GAD_FASTMACRO_EDIT:
  2770.                         case GAD_RATE_EDIT:
  2771.  
  2772.                             if(Selected != ~0)
  2773.                             {
  2774.                                 BOOLEAN Result = FALSE;
  2775.  
  2776.                                 LT_LockWindow(PhoneWindow);
  2777.                                 LT_LockWindow(EditWindow);
  2778.                                 LT_LockWindow(PatternWindow);
  2779.                                 LT_LockWindow(GroupWindow);
  2780.                                 LT_LockWindow(SortWindow);
  2781.  
  2782.                                 if(MsgGadgetID == GAD_RATE_EDIT)
  2783.                                 {
  2784.                                     if(SelectedNode -> Entry == ChosenEntry)
  2785.                                         MyEasyRequest(PhoneWindow,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_EDIT_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),DummyBuffer);
  2786.                                     else
  2787.                                         Result = RatePanel(PhoneWindow,PhoneList,SelectedNode -> Entry,NULL);
  2788.                                 }
  2789.                                 else
  2790.                                     Result = EditConfig(SelectedNode -> Entry -> Config,MsgGadgetID,MsgQualifier,PhoneWindow);
  2791.  
  2792.                                 if(Result)
  2793.                                 {
  2794.                                     HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,FALSE);
  2795.  
  2796.                                     PhonebookChanged = TRUE;
  2797.                                 }
  2798.  
  2799.                                 LT_UnlockWindow(PhoneWindow);
  2800.                                 LT_UnlockWindow(EditWindow);
  2801.                                 LT_UnlockWindow(PatternWindow);
  2802.                                 LT_UnlockWindow(GroupWindow);
  2803.                                 LT_UnlockWindow(SortWindow);
  2804.  
  2805.                                 LT_ShowWindow(Editor,TRUE);
  2806.                             }
  2807.  
  2808.                             break;
  2809.  
  2810.                             // Open the pattern selection window
  2811.  
  2812.                         case GAD_PATTERN:
  2813.  
  2814.                             if(PatternWindow)
  2815.                             {
  2816.                                 LT_ShowWindow(Selector,TRUE);
  2817.                                 LT_Activate(Selector,GAD_SELECT_NAME);
  2818.                             }
  2819.                             else
  2820.                             {
  2821.                                 if(Selector = CreateSelectorHandle(PhoneWindow,NamePattern,NumberPattern,CommentPattern,&Mode))
  2822.                                     PatternWindow = Selector -> Window;
  2823.                                 else
  2824.                                     DisplayBeep(PhoneWindow -> WScreen);
  2825.                             }
  2826.  
  2827.                             break;
  2828.  
  2829.                             // Apply the selection pattern to the phonebook
  2830.  
  2831.                         case GAD_SELECT_APPLY:
  2832.                         case GAD_SELECT_APPLY_AND_CLOSE:
  2833.  
  2834.                             ParsePatternNoCase(NamePattern,        ParsedNamePattern,        130);
  2835.                             ParsePatternNoCase(NumberPattern,    ParsedNumberPattern,    130);
  2836.                             ParsePatternNoCase(CommentPattern,    ParsedCommentPattern,    130);
  2837.  
  2838.                             LT_SetAttributes(Handle,GAD_NAMELIST,
  2839.                                 GTLV_Labels,    ~0,
  2840.                             TAG_DONE);
  2841.  
  2842.                             if(Mode)
  2843.                             {
  2844.                                 for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  2845.                                 {
  2846.                                     if(TempNode -> Entry -> Count == -1)
  2847.                                     {
  2848.                                         BOOL Result;
  2849.  
  2850.                                         Result = MatchPatternNoCase(ParsedNamePattern,TempNode -> Entry -> Header -> Name) & MatchPatternNoCase(ParsedNumberPattern,TempNode -> Entry -> Header -> Number) & MatchPatternNoCase(ParsedCommentPattern,TempNode -> Entry -> Header -> Comment);
  2851.  
  2852.                                         if(Result)
  2853.                                         {
  2854.                                             TempNode -> Entry -> Count = Count++;
  2855.  
  2856.                                             SPrintf(TempNode -> LocalName,"%3ld - %s",Count,TempNode -> Entry -> Header -> Name);
  2857.  
  2858.                                             if(TempNode -> Entry -> NodeGroup)
  2859.                                                 strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  2860.                                         }
  2861.                                     }
  2862.                                 }
  2863.                             }
  2864.                             else
  2865.                             {
  2866.                                 for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  2867.                                 {
  2868.                                     if(TempNode -> Entry -> Count != -1)
  2869.                                     {
  2870.                                         BOOL Result;
  2871.  
  2872.                                         Result = MatchPatternNoCase(ParsedNamePattern,TempNode -> Entry -> Header -> Name) & MatchPatternNoCase(ParsedNumberPattern,TempNode -> Entry -> Header -> Number) & MatchPatternNoCase(ParsedCommentPattern,TempNode -> Entry -> Header -> Comment);
  2873.  
  2874.                                         if(Result)
  2875.                                         {
  2876.                                             RemoveDialEntry(TempNode);
  2877.  
  2878.                                             Count--;
  2879.                                         }
  2880.                                     }
  2881.                                 }
  2882.                             }
  2883.  
  2884.                             HighlightEntry(Manager,Editor,CurrentList,SelectedNode,Count,PhonebookDefaultGroup,FALSE,Hide,TRUE);
  2885.                             UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  2886.  
  2887.                             if(Count > 0)
  2888.                             {
  2889.                                 LT_SetAttributes(Manager,GAD_MAKE_GROUP,
  2890.                                     GA_Disabled,FALSE,
  2891.                                 TAG_DONE);
  2892.                             }
  2893.  
  2894.                             if(MsgGadgetID == GAD_SELECT_APPLY)
  2895.                                 break;
  2896.  
  2897.                             // Close the pattern window
  2898.  
  2899.                         case GAD_SELECT_CLOSE:
  2900.  
  2901.                             LT_DeleteHandle(Selector);
  2902.                             Selector = NULL;
  2903.                             PatternWindow = NULL;
  2904.  
  2905.                             LT_ShowWindow(Manager,TRUE);
  2906.                             break;
  2907.  
  2908.                             // Dial the selected list
  2909.  
  2910.                         case GAD_DIAL:
  2911.  
  2912.                             if(!Count && Selected != ~0)
  2913.                             {
  2914.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  2915.                                     GTLV_Labels,    ~0,
  2916.                                 TAG_DONE);
  2917.  
  2918.                                 SPrintf(SelectedNode -> LocalName,"      %s",SelectedNode -> Entry -> Header -> Name);
  2919.  
  2920.                                 if(SelectedNode -> Entry -> NodeGroup)
  2921.                                     strcpy(SelectedNode -> Entry -> NodeGroup -> LocalName,SelectedNode -> Entry -> Header -> Name);
  2922.  
  2923.                                 SelectedNode -> Entry -> Count = Count++;
  2924.  
  2925.                                 LT_SetAttributes(Handle,GAD_NAMELIST,
  2926.                                     GTLV_Labels,    CurrentList,
  2927.                                 TAG_DONE);
  2928.                                 UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  2929.                             }
  2930.  
  2931.                                 /* If the modem is still online, provide help. */
  2932.  
  2933.                             if(Count > 0 && AskDial(PhoneWindow))
  2934.                             {
  2935.                                 DialTheList    = TRUE;
  2936.                                 Done        = TRUE;
  2937.                             }
  2938.  
  2939.                             break;
  2940.  
  2941.                             // Hit the autodial button
  2942.  
  2943.                         case GAD_MAIN_AUTODIAL:
  2944.  
  2945.                             LT_SetAttributes(Manager,GAD_MAIN_EXIT_WHEN_FINISHED,
  2946.                                 GA_Disabled,    !PhonebookAutoDial,
  2947.                             TAG_DONE);
  2948.  
  2949.                             break;
  2950.                     }
  2951.                 }
  2952.  
  2953.                     // Double-clicked on an entry?
  2954.  
  2955.                 if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadgetID == GAD_NAMELIST)
  2956.                 {
  2957.                     if(!(MsgQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)) && !Online && Phonebook[MsgCode] -> Header -> Number[0])
  2958.                     {
  2959.                         Selected = MsgCode;
  2960.  
  2961.                         if(PhonebookDefaultGroup)
  2962.                             SelectedNode = (struct PhoneNode *)GetListNode(Selected,CurrentList);
  2963.                         else
  2964.                             SelectedNode = Phonebook[Selected] -> Node;
  2965.  
  2966.                         LT_SetAttributes(Handle,GAD_NAMELIST,
  2967.                             GTLV_Labels,    ~0,
  2968.                         TAG_DONE);
  2969.  
  2970.                         Count = 1;
  2971.  
  2972.                         for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  2973.                         {
  2974.                             if(TempNode != SelectedNode)
  2975.                             {
  2976.                                 SPrintf(TempNode -> LocalName,"      %s",TempNode -> Entry -> Header -> Name);
  2977.  
  2978.                                 TempNode -> Entry -> Count = -1;
  2979.                             }
  2980.                             else
  2981.                             {
  2982.                                 SPrintf(TempNode -> LocalName,"  1 - %s",TempNode -> Entry -> Header -> Name);
  2983.  
  2984.                                 TempNode -> Entry -> Count = 0;
  2985.                             }
  2986.  
  2987.                             if(TempNode -> Entry -> NodeGroup)
  2988.                                 strcpy(TempNode -> Entry -> NodeGroup -> LocalName,TempNode -> LocalName);
  2989.                         }
  2990.  
  2991.                         DialTheList    = TRUE;
  2992.                         Done        = TRUE;
  2993.  
  2994.                         LT_PressButton(Handle,GAD_DIAL);
  2995.                         UpdateWindowTitle(PhoneWindow,WindowTitle,Count);
  2996.                     }
  2997.                 }
  2998.             }
  2999.         }
  3000.         while(!Done);
  3001.  
  3002.         PopWindow();
  3003.     }
  3004.  
  3005.     LT_DeleteHandle(Grouping);
  3006.     LT_DeleteHandle(Selector);
  3007.     LT_DeleteHandle(Manager);
  3008.     LT_DeleteHandle(Editor);
  3009.     LT_DeleteHandle(Sorting);
  3010.  
  3011.     if(PhonebookChanged)
  3012.         RebuildMenu = TRUE;
  3013.  
  3014.     FreeDialList(TRUE);
  3015.  
  3016.     if(PhoneList)
  3017.     {
  3018.         if(Count > 0)
  3019.         {
  3020.             for(TempNode = (struct PhoneNode *)CurrentList -> lh_Head ; TempNode -> VanillaNode . ln_Succ ; TempNode = (struct PhoneNode *)TempNode -> VanillaNode . ln_Succ)
  3021.             {
  3022.                 if(TempNode -> Entry -> Count != -1 && TempNode -> Entry -> Header -> Number[0])
  3023.                     SortToList(TempNode,NULL);
  3024.             }
  3025.  
  3026.             if(!DialList)
  3027.                 DialTheList = FALSE;
  3028.         }
  3029.  
  3030.         DeletePhoneList(PhoneList);
  3031.     }
  3032.  
  3033.     if(RebuildMenu)
  3034.         DisconnectDialMenu();
  3035.  
  3036.     FreeVecPooled(Labels);
  3037.     DeleteMsgPort(UserPort);
  3038.  
  3039.     return(DialTheList);
  3040. }
  3041.